Revert "API solved"

This reverts commit 0f16c64a587e372a3a073c11e3f7e374cae9dbfd.

README.md

@@ -19,104 +19,11 @@ A powerful chatbot that can answer questions by querying your SQL database using
 - Interactive chat interface
 - Direct database connectivity
 - Powered by Google's Gemini AI
-- RESTful API endpoints for integration
 
 ## Setup
 
-1. Set up your environment variables in `.env` file:
-```env
-DB_USER=tu_usuario
-DB_PASSWORD=tu_contraseña
-DB_HOST=tu_servidor
-DB_NAME=tu_base_de_datos
-GOOGLE_API_KEY=tu_api_key_de_google
-```
-
-2. Install dependencies:
-```bash
-pip install -r requirements.txt
-```
-
-3. Run the web interface:
-```bash
-python app.py
-```
-
-4. Run the API server:
-```bash
-python api.py
-```
-
-## API Usage
-
-La API proporciona dos endpoints principales:
-
-### 1. Enviar Mensaje de Usuario
-
-**Endpoint:** `/user_message`
-
-**Método:** POST
-
-**Headers:**
-```
-Content-Type: application/json
-```
-
-**Body:**
-```json
-{
-    "message": "tu pregunta aquí"
-}
-```
-
-**Respuesta exitosa:**
-```json
-{
-    "message_id": "uuid-generado",
-    "status": "success"
-}
-```
-
-### 2. Obtener Respuesta
-
-**Endpoint:** `/ask`
-
-**Método:** POST
-
-**Headers:**
-```
-Content-Type: application/json
-```
-
-**Body:**
-```json
-{
-    "message_id": "uuid-del-mensaje"
-}
-```
-
-**Respuesta exitosa:**
-```json
-{
-    "response": "respuesta del chatbot",
-    "status": "success"
-}
-```
-
-## Ejemplo de uso de la API
-
-1. Primero, envía tu pregunta:
-```bash
-curl -X POST http://localhost:5000/user_message \
-     -H "Content-Type: application/json" \
-     -d '{"message": "¿Cuántos usuarios hay en la base de datos?"}'
-```
-
-2. Luego, usa el message_id recibido para obtener la respuesta:
-```bash
-curl -X POST http://localhost:5000/ask \
-     -H "Content-Type: application/json" \
-     -d '{"message_id": "uuid-recibido"}'
-```
+1. Set up your environment variables in `.env` file
+2. Install dependencies: `pip install -r requirements.txt`
+3. Run the app: `python app.py`
 
 Check out the [configuration reference](https://huggingface.co/docs/hub/spaces-config-reference) for more options.

api.py

@@ -1,103 +0,0 @@
-from flask import Flask, request, jsonify
-from typing import Dict, Optional
-import uuid
-import os
-from app import initialize_llm, setup_database_connection, create_agent, gr
-
-app = Flask(__name__)
-
-# Almacenamiento en memoria de los mensajes
-message_store: Dict[str, str] = {}
-
-@app.route('/user_message', methods=['POST'])
-def handle_user_message():
-    try:
-        data = request.get_json()
-        if not data or 'message' not in data:
-            return jsonify({'error': 'Se requiere el campo message'}), 400
-            
-        user_message = data['message']
-        
-        # Generar un ID único para este mensaje
-        message_id = str(uuid.uuid4())
-        
-        # Almacenar el mensaje
-        message_store[message_id] = user_message
-        
-        return jsonify({
-            'message_id': message_id,
-            'status': 'success'
-        })
-        
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/ask', methods=['POST'])
-def handle_ask():
-    try:
-        data = request.get_json()
-        if not data or 'message_id' not in data:
-            return jsonify({'error': 'Se requiere el campo message_id'}), 400
-            
-        message_id = data['message_id']
-        
-        # Recuperar el mensaje almacenado
-        if message_id not in message_store:
-            return jsonify({'error': 'ID de mensaje no encontrado'}), 404
-            
-        user_message = message_store[message_id]
-        
-        # Inicializar componentes necesarios
-        llm, llm_error = initialize_llm()
-        if llm_error:
-            return jsonify({'error': f'Error al inicializar LLM: {llm_error}'}), 500
-            
-        db_connection, db_error = setup_database_connection()
-        if db_error:
-            return jsonify({'error': f'Error de conexión a la base de datos: {db_error}'}), 500
-            
-        agent, agent_error = create_agent(llm, db_connection)
-        if agent_error:
-            return jsonify({'error': f'Error al crear el agente: {agent_error}'}), 500
-        
-        # Obtener respuesta del agente
-        response = agent.invoke({"input": user_message})
-        
-        # Procesar la respuesta
-        if hasattr(response, 'output') and response.output:
-            response_text = response.output
-        elif isinstance(response, str):
-            response_text = response
-        elif hasattr(response, 'get') and callable(response.get) and 'output' in response:
-            response_text = response['output']
-        else:
-            response_text = str(response)
-        
-        # Eliminar el mensaje almacenado después de procesarlo
-        del message_store[message_id]
-        
-        return jsonify({
-            'response': response_text,
-            'status': 'success'
-        })
-        
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-# Integración con Gradio para Hugging Face Spaces
-def mount_in_app(gradio_app):
-    """Monta la API Flask en la aplicación Gradio."""
-    return gradio_app
-
-if __name__ == '__main__':
-    # Si se ejecuta directamente, inicia el servidor Flask
-    port = int(os.environ.get('PORT', 5000))
-    app.run(host='0.0.0.0', port=port)
-else:
-    # Si se importa como módulo (en Hugging Face Spaces),
-    # expone la función para montar en Gradio
-    gradio_app = gr.mount_gradio_app(
-        app,
-        "/api",  # Prefijo para los endpoints de la API
-        lambda: True  # Autenticación deshabilitada
-    )

app.py

@@ -12,23 +12,976 @@ import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
-from api import app as flask_app
+try:
+    from sqlalchemy import text as sa_text
+except Exception:
+    sa_text = None
 
-# ... (resto del código existente sin cambios) ...
+try:
+    # Intentar importar dependencias opcionales
+    from langchain_community.agent_toolkits import create_sql_agent
+    from langchain_community.agent_toolkits.sql.toolkit import SQLDatabaseToolkit
+    from langchain_community.utilities import SQLDatabase
+    from langchain_google_genai import ChatGoogleGenerativeAI
+    from langchain.agents.agent_types import AgentType
+    from langchain.memory import ConversationBufferWindowMemory
+    from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+    import pymysql
+    from dotenv import load_dotenv
+    
+    DEPENDENCIES_AVAILABLE = True
+except ImportError as e:
+    logger.warning(f"Some dependencies are not available: {e}")
+    DEPENDENCIES_AVAILABLE = False
+
+# Configuración de logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+
+def generate_chart(data: Union[Dict, List[Dict], pd.DataFrame], 
+                 chart_type: str, 
+                 x: str, 
+                 y: str = None, 
+                 title: str = "", 
+                 x_label: str = None, 
+                 y_label: str = None):
+    """
+    Generate an interactive Plotly figure from data.
+    
+    Args:
+        data: The data to plot (can be a list of dicts or a pandas DataFrame)
+        chart_type: Type of chart to generate (bar, line, pie, scatter, histogram)
+        x: Column name for x-axis (names for pie)
+        y: Column name for y-axis (values for pie)
+        title: Chart title
+        x_label: Label for x-axis
+        y_label: Label for y-axis
+        
+    Returns:
+        A Plotly Figure object (interactive) or None on error
+    """
+    try:
+        # Convert data to DataFrame if it's a list of dicts
+        if isinstance(data, list):
+            df = pd.DataFrame(data)
+        elif isinstance(data, dict):
+            df = pd.DataFrame([data])
+        else:
+            df = data
+            
+        if not isinstance(df, pd.DataFrame):
+            return None
+            
+        # Generate the appropriate chart type
+        fig = None
+        if chart_type == 'bar':
+            fig = px.bar(df, x=x, y=y, title=title)
+        elif chart_type == 'line':
+            fig = px.line(df, x=x, y=y, title=title)
+        elif chart_type == 'pie':
+            fig = px.pie(df, names=x, values=y, title=title, hole=0)
+        elif chart_type == 'scatter':
+            fig = px.scatter(df, x=x, y=y, title=title)
+        elif chart_type == 'histogram':
+            fig = px.histogram(df, x=x, title=title)
+        else:
+            return None
+        
+        # Update layout
+        fig.update_layout(
+            xaxis_title=x_label or x,
+            yaxis_title=y_label or (y if y != x else ''),
+            title=title or f"{chart_type.capitalize()} Chart of {x} vs {y}" if y else f"{chart_type.capitalize()} Chart of {x}",
+            template="plotly_white",
+            margin=dict(l=20, r=20, t=40, b=20),
+            height=400
+        )
+        
+        return fig
+        
+    except Exception as e:
+        error_msg = f"Error generating chart: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        return None
+
+logger = logging.getLogger(__name__)
+
+def check_environment():
+    """Verifica si el entorno está configurado correctamente."""
+    if not DEPENDENCIES_AVAILABLE:
+        return False, "Missing required Python packages. Please install them with: pip install -r requirements.txt"
+    
+    # Verificar si estamos en un entorno con variables de entorno
+    required_vars = ["DB_USER", "DB_PASSWORD", "DB_HOST", "DB_NAME", "GOOGLE_API_KEY"]
+    missing_vars = [var for var in required_vars if not os.getenv(var)]
+    
+    if missing_vars:
+        return False, f"Missing required environment variables: {', '.join(missing_vars)}"
+    
+    return True, "Environment is properly configured"
+
+def setup_database_connection():
+    """Intenta establecer una conexión a la base de datos."""
+    if not DEPENDENCIES_AVAILABLE:
+        return None, "Dependencies not available"
+        
+    try:
+        load_dotenv(override=True)
+        
+        # Debug: Log all environment variables (without sensitive values)
+        logger.info("Environment variables:")
+        for key, value in os.environ.items():
+            if any(s in key.lower() for s in ['pass', 'key', 'secret']):
+                logger.info(f"  {key}: {'*' * 8} (hidden for security)")
+            else:
+                logger.info(f"  {key}: {value}")
+        
+        db_user = os.getenv("DB_USER")
+        db_password = os.getenv("DB_PASSWORD")
+        db_host = os.getenv("DB_HOST")
+        db_name = os.getenv("DB_NAME")
+        
+        # Debug: Log database connection info (without password)
+        logger.info(f"Database connection attempt - Host: {db_host}, User: {db_user}, DB: {db_name}")
+        if not all([db_user, db_password, db_host, db_name]):
+            missing = [var for var, val in [
+                ("DB_USER", db_user),
+                ("DB_PASSWORD", "*" if db_password else ""),
+                ("DB_HOST", db_host),
+                ("DB_NAME", db_name)
+            ] if not val]
+            logger.error(f"Missing required database configuration: {', '.join(missing)}")
+            return None, f"Missing database configuration: {', '.join(missing)}"
+        
+        if not all([db_user, db_password, db_host, db_name]):
+            return None, "Missing database configuration"
+            
+        logger.info(f"Connecting to database: {db_user}@{db_host}/{db_name}")
+        
+        # Probar conexión
+        connection = pymysql.connect(
+            host=db_host,
+            user=db_user,
+            password=db_password,
+            database=db_name,
+            connect_timeout=5,
+            cursorclass=pymysql.cursors.DictCursor
+        )
+        connection.close()
+        
+        # Si la conexión es exitosa, crear motor SQLAlchemy
+        db_uri = f"mysql+pymysql://{db_user}:{db_password}@{db_host}/{db_name}"
+        logger.info("Database connection successful")
+        return SQLDatabase.from_uri(db_uri), ""
+        
+    except Exception as e:
+        error_msg = f"Error connecting to database: {str(e)}"
+        logger.error(error_msg)
+        return None, error_msg
+
+def initialize_llm():
+    """Inicializa el modelo de lenguaje."""
+    if not DEPENDENCIES_AVAILABLE:
+        error_msg = "Dependencies not available. Make sure all required packages are installed."
+        logger.error(error_msg)
+        return None, error_msg
+        
+    google_api_key = os.getenv("GOOGLE_API_KEY")
+    logger.info(f"GOOGLE_API_KEY found: {'Yes' if google_api_key else 'No'}")
+    
+    if not google_api_key:
+        error_msg = "GOOGLE_API_KEY not found in environment variables. Please check your Hugging Face Space secrets."
+        logger.error(error_msg)
+        return None, error_msg
+        
+    try:
+        logger.info("Initializing Google Generative AI...")
+        llm = ChatGoogleGenerativeAI(
+            model="gemini-2.0-flash",
+            temperature=0,
+            google_api_key=google_api_key,
+            convert_system_message_to_human=True  # Convert system messages to human messages
+        )
+        
+        # Test the model with a simple prompt
+        test_prompt = "Hello, this is a test."
+        logger.info(f"Testing model with prompt: {test_prompt}")
+        test_response = llm.invoke(test_prompt)
+        logger.info(f"Model test response: {str(test_response)[:100]}...")  # Log first 100 chars
+        
+        logger.info("Google Generative AI initialized successfully")
+        return llm, ""
+        
+    except Exception as e:
+        error_msg = f"Error initializing Google Generative AI: {str(e)}"
+        logger.error(error_msg, exc_info=True)  # Include full stack trace
+        return None, error_msg
+
+def create_agent():
+    """Crea el agente SQL si es posible."""
+    if not DEPENDENCIES_AVAILABLE:
+        error_msg = "Dependencies not available. Please check if all required packages are installed."
+        logger.error(error_msg)
+        return None, error_msg
+    
+    logger.info("Starting agent creation process...")
+    
+def create_agent(llm, db_connection):
+    """Create and return a SQL database agent with conversation memory."""
+    if not llm:
+        error_msg = "Cannot create agent: LLM is not available"
+        logger.error(error_msg)
+        return None, error_msg
+    
+    if not db_connection:
+        error_msg = "Cannot create agent: Database connection is not available"
+        logger.error(error_msg)
+        return None, error_msg
+        
+    try:
+        logger.info("Creating SQL agent with memory...")
+        
+        # Create conversation memory
+        memory = ConversationBufferWindowMemory(
+            memory_key="chat_history",
+            k=5,  # Keep last 5 message exchanges in memory
+            return_messages=True,
+            output_key="output"
+        )
+        
+        # Create the database toolkit with additional configuration
+        toolkit = SQLDatabaseToolkit(
+            db=db_connection,
+            llm=llm
+        )
+        
+        # Create the agent with memory and more detailed configuration
+        agent = create_sql_agent(
+            llm=llm,
+            toolkit=toolkit,
+            agent_type=AgentType.OPENAI_FUNCTIONS,
+            verbose=True,
+            handle_parsing_errors=True,  # Better error handling for parsing
+            max_iterations=10,  # Limit the number of iterations
+            early_stopping_method="generate",  # Stop early if the agent is stuck
+            memory=memory,  # Add memory to the agent
+            return_intermediate_steps=True  # Important for memory to work properly
+        )
+        
+        # Test the agent with a simple query
+        logger.info("Testing agent with a simple query...")
+        try:
+            test_query = "SELECT 1"
+            test_result = agent.run(test_query)
+            logger.info(f"Agent test query successful: {str(test_result)[:200]}...")
+        except Exception as e:
+            logger.warning(f"Agent test query failed (this might be expected): {str(e)}")
+            # Continue even if test fails, as it might be due to model limitations
+        
+        logger.info("SQL agent created successfully")
+        return agent, ""
+        
+    except Exception as e:
+        error_msg = f"Error creating SQL agent: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        return None, error_msg
+
+# Inicializar el agente
+logger.info("="*50)
+logger.info("Starting application initialization...")
+logger.info(f"Python version: {sys.version}")
+logger.info(f"Current working directory: {os.getcwd()}")
+logger.info(f"Files in working directory: {os.listdir()}")
+
+# Verificar las variables de entorno
+logger.info("Checking environment variables...")
+for var in ["DB_USER", "DB_PASSWORD", "DB_HOST", "DB_NAME", "GOOGLE_API_KEY"]:
+    logger.info(f"{var}: {'*' * 8 if os.getenv(var) else 'NOT SET'}")
+
+# Initialize components
+logger.info("Initializing database connection...")
+db_connection, db_error = setup_database_connection()
+if db_error:
+    logger.error(f"Failed to initialize database: {db_error}")
+
+logger.info("Initializing language model...")
+llm, llm_error = initialize_llm()
+if llm_error:
+    logger.error(f"Failed to initialize language model: {llm_error}")
+
+logger.info("Initializing agent...")
+agent, agent_error = create_agent(llm, db_connection)
+db_connected = agent is not None
+
+if agent:
+    logger.info("Agent initialized successfully")
+else:
+    logger.error(f"Failed to initialize agent: {agent_error}")
+
+logger.info("="*50)
+
+def looks_like_sql(s: str) -> bool:
+    """Heuristic to check if a string looks like an executable SQL statement."""
+    if not s:
+        return False
+    s_strip = s.strip().lstrip("-- ")
+    # common starters
+    return bool(re.match(r"^(WITH|SELECT|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP|TRUNCATE)\b", s_strip, re.IGNORECASE))
+
+
+def extract_sql_query(text):
+    """Extrae consultas SQL del texto. Acepta solo bloques etiquetados como ```sql
+    o cadenas que claramente parezcan SQL. Evita ejecutar texto genérico.
+    """
+    if not text:
+        return None
+
+    # Buscar TODOS los bloques en backticks y elegir los que sean 'sql'
+    for m in re.finditer(r"```(\w+)?\s*(.*?)```", text, re.DOTALL | re.IGNORECASE):
+        lang = (m.group(1) or '').lower()
+        body = (m.group(2) or '').strip()
+        if lang in {"sql", "postgresql", "mysql"} and looks_like_sql(body):
+            return body
+
+    # Si no hay bloques etiquetados, buscar una consulta SQL simple con palabras clave
+    simple = re.search(r"(WITH|SELECT|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP|TRUNCATE)[\s\S]*?;", text, re.IGNORECASE)
+    if simple:
+        candidate = simple.group(0).strip()
+        if looks_like_sql(candidate):
+            return candidate
+
+    return None
+
+def execute_sql_query(query, db_connection):
+    """Ejecuta una consulta SQL y devuelve los resultados como una cadena."""
+    if not db_connection:
+        return "Error: No hay conexión a la base de datos"
+        
+    try:
+        with db_connection._engine.connect() as connection:
+            # Ensure SQLAlchemy receives a SQL expression
+            if sa_text is not None and isinstance(query, str):
+                result = connection.execute(sa_text(query))
+            else:
+                result = connection.execute(query)
+
+            # Fetch data and column names
+            columns = list(result.keys()) if hasattr(result, "keys") else []
+            rows = result.fetchall()
+
+            # Convertir los resultados a un formato legible
+            if not rows:
+                return "La consulta no devolvió resultados"
+
+            # Si es un solo resultado, devolverlo directamente
+            try:
+                if len(rows) == 1 and len(rows[0]) == 1:
+                    return str(rows[0][0])
+            except Exception:
+                pass
+
+            # Si hay múltiples filas, formatear como tabla Markdown
+            try:
+                import pandas as pd
+
+                # Convert SQLAlchemy Row objects to list of dicts using column names
+                if columns:
+                    data = [
+                        {col: val for col, val in zip(columns, tuple(row))}
+                        for row in rows
+                    ]
+                    df = pd.DataFrame(data)
+                else:
+                    # Fallback: let pandas infer columns
+                    df = pd.DataFrame(rows)
+
+                # Prefer Markdown output for downstream chart parsing
+                try:
+                    return df.to_markdown(index=False)
+                except Exception:
+                    # If optional dependency 'tabulate' is missing, build a simple Markdown table
+                    headers = list(map(str, df.columns))
+                    header_line = "| " + " | ".join(headers) + " |"
+                    sep_line = "| " + " | ".join(["---"] * len(headers)) + " |"
+                    body_lines = []
+                    for _, r in df.iterrows():
+                        body_lines.append("| " + " | ".join(map(lambda v: str(v), r.values)) + " |")
+                    return "\n".join([header_line, sep_line, *body_lines])
+            except ImportError:
+                # Si pandas no está disponible, usar formato simple
+                return "\n".join([str(row) for row in rows])
+
+    except Exception as e:
+        return f"Error ejecutando la consulta: {str(e)}"
+
+def detect_chart_preferences(question: str) -> Tuple[bool, str]:
+    """Detect whether the user is asking for a chart and infer desired type.
+
+    Returns (wants_chart, chart_type) where chart_type is one of
+    {'bar', 'pie', 'line', 'scatter', 'histogram'}.
+    Defaults to 'bar' when ambiguous.
+    """
+    try:
+        q = (question or "").lower()
+
+        # Broad triggers indicating any chart request
+        chart_triggers = [
+            "grafico", "gráfico", "grafica", "gráfica", "chart", "graph",
+            "visualizacion", "visualización", "plot", "plotly", "diagrama"
+        ]
+        wants_chart = any(k in q for k in chart_triggers)
+
+        # Specific type hints
+        if any(k in q for k in ["pastel", "pie", "circular", "donut", "dona", "anillo"]):
+            return wants_chart or True, "pie"
+        if any(k in q for k in ["linea", "línea", "line", "tendencia"]):
+            return wants_chart or True, "line"
+        if any(k in q for k in ["dispersión", "dispersion", "scatter", "puntos"]):
+            return wants_chart or True, "scatter"
+        if any(k in q for k in ["histograma", "histogram"]):
+            return wants_chart or True, "histogram"
+        if any(k in q for k in ["barra", "barras", "columnas", "column"]):
+            return wants_chart or True, "bar"
+
+        # Default
+        return wants_chart, "bar"
+    except Exception:
+        return False, "bar"
+
+def generate_plot(data, x_col, y_col, title, x_label, y_label):
+    """Generate a plot from data and return the file path."""
+    plt.figure(figsize=(10, 6))
+    plt.bar(data[x_col], data[y_col])
+    plt.title(title)
+    plt.xlabel(x_label)
+    plt.ylabel(y_label)
+    plt.xticks(rotation=45)
+    plt.tight_layout()
+    
+    # Save to a temporary file
+    temp_dir = tempfile.mkdtemp()
+    plot_path = os.path.join(temp_dir, "plot.png")
+    plt.savefig(plot_path)
+    plt.close()
+    
+    return plot_path
+
+def convert_to_messages_format(chat_history):
+    """Convert chat history to the format expected by Gradio 5.x"""
+    if not chat_history:
+        return []
+        
+    messages = []
+    
+    # If the first element is a list, assume it's in the old format
+    if isinstance(chat_history[0], list):
+        for msg in chat_history:
+            if isinstance(msg, list) and len(msg) == 2:
+                # Format: [user_msg, bot_msg]
+                user_msg, bot_msg = msg
+                if user_msg:
+                    messages.append({"role": "user", "content": user_msg})
+                if bot_msg:
+                    messages.append({"role": "assistant", "content": bot_msg})
+    else:
+        # Assume it's already in the correct format or can be used as is
+        for msg in chat_history:
+            if isinstance(msg, dict) and "role" in msg and "content" in msg:
+                messages.append(msg)
+            elif isinstance(msg, str):
+                # If it's a string, assume it's a user message
+                messages.append({"role": "user", "content": msg})
+    
+    return messages
+
+async def stream_agent_response(question: str, chat_history: List[List[str]]) -> Tuple[str, Optional["go.Figure"]]:
+    """Procesa la pregunta del usuario y devuelve la respuesta del agente con memoria de conversación."""
+    global agent  # Make sure we can modify the agent's memory
+    
+    # Initialize response
+    response_text = ""
+    chart_fig = None
+    messages = []
+    
+    # Add previous chat history in the correct format for the agent
+    for msg_pair in chat_history:
+        if len(msg_pair) >= 1 and msg_pair[0]:  # User message
+            messages.append(HumanMessage(content=msg_pair[0]))
+        if len(msg_pair) >= 2 and msg_pair[1]:  # Assistant message
+            messages.append(AIMessage(content=msg_pair[1]))
+    
+    # Add current user's question
+    user_message = HumanMessage(content=question)
+    messages.append(user_message)
+    
+    if not agent:
+        error_msg = (
+            "## ⚠️ Error: Agente no inicializado\n\n"
+            "No se pudo inicializar el agente de base de datos. Por favor, verifica que:\n"
+            "1. Todas las variables de entorno estén configuradas correctamente\n"
+            "2. La base de datos esté accesible\n"
+            f"3. El modelo de lenguaje esté disponible\n\n"
+            f"Error: {agent_error}"
+        )
+        return error_msg, None
+        
+    # Update the agent's memory with the full conversation history
+    try:
+        # Rebuild agent memory from chat history pairs
+        if hasattr(agent, 'memory') and agent.memory is not None:
+            agent.memory.clear()
+            for i in range(0, len(messages)-1, 2):  # (user, assistant)
+                if i+1 < len(messages):
+                    agent.memory.save_context(
+                        {"input": messages[i].content},
+                        {"output": messages[i+1].content}
+                    )
+    except Exception as e:
+        logger.error(f"Error updating agent memory: {str(e)}", exc_info=True)
+    
+    try:
+        # Add empty assistant message that will be updated
+        assistant_message = {"role": "assistant", "content": ""}
+        messages.append(assistant_message)
+        
+        # Execute the agent with proper error handling
+        try:
+            # Let the agent use its memory; don't pass raw chat_history
+            response = await agent.ainvoke({"input": question})
+            logger.info(f"Agent response type: {type(response)}")
+            logger.info(f"Agent response content: {str(response)[:500]}...")
+            
+            # Handle different response formats
+            if hasattr(response, 'output') and response.output:
+                response_text = response.output
+            elif isinstance(response, str):
+                response_text = response
+            elif hasattr(response, 'get') and callable(response.get) and 'output' in response:
+                response_text = response['output']
+            else:
+                response_text = str(response)
+            
+            # logger.info(f"Extracted response text: {response_text[:200]}...")
+            
+            # # Check if the response contains an SQL query and it truly looks like SQL
+            # sql_query = extract_sql_query(response_text)
+            # if sql_query and looks_like_sql(sql_query):
+            #     logger.info(f"Detected SQL query: {sql_query}")
+            #     # Execute the query and update the response
+            #     db_connection, _ = setup_database_connection()
+            #     if db_connection:
+            #         query_result = execute_sql_query(sql_query, db_connection)
+                    
+            #         # Add the query and its result to the response
+            #         response_text += f"\n\n### 🔍 Resultado de la consulta:\n```sql\n{sql_query}\n```\n\n{query_result}"
+                    
+            #         # Try to generate an interactive chart if the result is tabular
+            #         try:
+            #             if isinstance(query_result, str) and '|' in query_result and '---' in query_result:
+            #                 # Convert markdown table to DataFrame
+                            
+            #                 # Clean up the markdown table
+            #                 lines = [line.strip() for line in query_result.split('\n') 
+            #                         if line.strip() and '---' not in line and '|' in line]
+            #                 if len(lines) > 1:  # At least header + 1 data row
+            #                     # Get column names from the first line
+            #                     columns = [col.strip() for col in lines[0].split('|')[1:-1]]
+            #                     # Get data rows
+            #                     data = []
+            #                     for line in lines[1:]:
+            #                         values = [val.strip() for val in line.split('|')[1:-1]]
+            #                         if len(values) == len(columns):
+            #                             data.append(dict(zip(columns, values)))
+                                
+            #                     if data and len(columns) >= 2:
+            #                         # Determine chart type from user's question
+            #                         _, desired_type = detect_chart_preferences(question)
+
+            #                         # Choose x/y columns (assume first is category, second numeric)
+            #                         x_col = columns[0]
+            #                         y_col = columns[1]
+
+            #                         # Coerce numeric values for y
+            #                         for row in data:
+            #                             try:
+            #                                 row[y_col] = float(re.sub(r"[^0-9.\-]", "", str(row[y_col])))
+            #                             except Exception:
+            #                                 pass
+
+            #                         chart_fig = generate_chart(
+            #                             data=data,
+            #                             chart_type=desired_type,
+            #                             x=x_col,
+            #                             y=y_col,
+            #                             title=f"{y_col} por {x_col}"
+            #                         )
+            #                         if chart_fig is not None:
+            #                             logger.info(f"Chart generated from SQL table: type={desired_type}, x={x_col}, y={y_col}, rows={len(data)}")
+            #         except Exception as e:
+            #             logger.error(f"Error generating chart: {str(e)}", exc_info=True)
+            #             # Don't fail the whole request if chart generation fails
+            #             response_text += "\n\n⚠️ No se pudo generar la visualización de los datos."
+            #     else:
+            #         response_text += "\n\n⚠️ No se pudo conectar a la base de datos para ejecutar la consulta."
+            # elif sql_query and not looks_like_sql(sql_query):
+            #     logger.info("Detected code block but it does not look like SQL; skipping execution.")
+
+            # If we still have no chart but the user clearly wants one,
+            # try a second pass to get ONLY a SQL query from the agent and execute it.
+            if chart_fig is None:
+                wants_chart, default_type = detect_chart_preferences(question)
+                if wants_chart:
+                    try:
+                        logger.info("Second pass: asking agent for ONLY SQL query in fenced block.")
+                        sql_only_prompt = (
+                            "Devuelve SOLO la consulta SQL en un bloque ```sql``` para responder a: "
+                            f"{question}. No incluyas explicación ni texto adicional."
+                        )
+                        sql_only_resp = await agent.ainvoke({"input": sql_only_prompt})
+                        sql_only_text = str(sql_only_resp)
+                        sql_query2 = extract_sql_query(sql_only_text)
+                        if sql_query2 and looks_like_sql(sql_query2):
+                            logger.info(f"Second pass SQL detected: {sql_query2}")
+                            db_connection, _ = setup_database_connection()
+                            if db_connection:
+                                query_result = execute_sql_query(sql_query2, db_connection)
+                                # Try to parse table-like text into DataFrame if possible
+                                data = None
+                                if isinstance(query_result, str):
+                                    try:
+                                        import pandas as pd
+                                        df = pd.read_csv(io.StringIO(query_result), sep="|")
+                                        data = df
+                                    except Exception:
+                                        pass
+                                # As a fallback, don't rely on text table; just skip charting here
+                                if data is not None and hasattr(data, "empty") and not data.empty:
+                                    # Heuristics: choose first column as x and second as y if numeric
+                                    x_col = data.columns[0]
+                                    # pick first numeric column different to x
+                                    y_col = None
+                                    for col in data.columns[1:]:
+                                        try:
+                                            pd.to_numeric(data[col])
+                                            y_col = col
+                                            break
+                                        except Exception:
+                                            continue
+                                    if y_col:
+                                        desired_type = default_type
+                                        chart_fig = generate_chart(
+                                            data=data,
+                                            chart_type=desired_type,
+                                            x=x_col,
+                                            y=y_col,
+                                            title=f"{y_col} por {x_col}"
+                                        )
+                                        if chart_fig is not None:
+                                            logger.info("Chart generated from second-pass SQL execution.")
+                            else:
+                                logger.info("No DB connection on second pass; skipping.")
+                    except Exception as e:
+                        logger.error(f"Second-pass SQL synthesis failed: {e}")
+            
+            # Fallback: if user asked for a chart and we didn't get SQL or chart yet,
+            # parse the most recent assistant text for lines like "LABEL: NUMBER" (bulleted or plain).
+            if chart_fig is None:
+                wants_chart, desired_type = detect_chart_preferences(question)
+                if wants_chart:
+                    # Find the most recent assistant message with usable numeric pairs
+                    candidate_text = ""
+                    if chat_history:
+                        for pair in reversed(chat_history):
+                            if len(pair) >= 2 and isinstance(pair[1], str) and pair[1].strip():
+                                candidate_text = pair[1]
+                                break
+                    # Also consider current response_text as a data source
+                    if not candidate_text and isinstance(response_text, str) and response_text.strip():
+                        candidate_text = response_text
+                    if candidate_text:
+                        raw_lines = candidate_text.split('\n')
+                        # Normalize lines: strip bullets and markdown symbols
+                        norm_lines = []
+                        for l in raw_lines:
+                            s = l.strip()
+                            if not s:
+                                continue
+                            s = s.lstrip("•*-\t ")
+                            # Remove surrounding markdown emphasis from labels later
+                            norm_lines.append(s)
+                        data = []
+                        for l in norm_lines:
+                            # Accept patterns like "**LABEL**: 123" or "LABEL: 1,234"
+                            m = re.match(r"^(.+?):\s*([0-9][0-9.,]*)$", l)
+                            if m:
+                                label = m.group(1).strip()
+                                # Strip common markdown emphasis
+                                label = re.sub(r"[*_`]+", "", label).strip()
+                                try:
+                                    val = float(m.group(2).replace(',', ''))
+                                except Exception:
+                                    continue
+                                data.append({"label": label, "value": val})
+                        logger.info(f"Fallback parse from text: extracted {len(data)} items for potential chart")
+                        if len(data) >= 2:
+                            chart_fig = generate_chart(
+                                data=data,
+                                chart_type=desired_type,
+                                x="label",
+                                y="value",
+                                title="Distribución"
+                            )
+                            if chart_fig is not None:
+                                logger.info(f"Chart generated from text fallback: type={desired_type}, items={len(data)}")
+            
+            # Update the assistant's message with the response
+            assistant_message["content"] = response_text
+            
+        except Exception as e:
+            error_msg = f"Error al ejecutar el agente: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            assistant_message["content"] = f"## ❌ Error\n\n{error_msg}"
+        
+        # Return the message in the correct format for Gradio Chatbot
+        # Format: list of tuples where each tuple is (user_msg, bot_msg)
+        # For a single response, we return [(None, message)]
+        message_content = ""
+        
+        if isinstance(assistant_message, dict) and "content" in assistant_message:
+            message_content = assistant_message["content"]
+        elif isinstance(assistant_message, str):
+            message_content = assistant_message
+        else:
+            message_content = str(assistant_message)
+            
+        # Return the assistant's response and an optional interactive chart figure
+        if chart_fig is None:
+            logger.info("No chart generated for this turn.")
+        else:
+            logger.info("Returning a chart figure to UI.")
+        return message_content, chart_fig
+        
+    except Exception as e:
+        error_msg = f"## ❌ Error\n\nOcurrió un error al procesar tu solicitud:\n\n```\n{str(e)}\n```"
+        logger.error(f"Error in stream_agent_response: {str(e)}", exc_info=True)
+        # Return error message and no chart
+        return error_msg, None
+
+# Custom CSS for the app
+custom_css = """
+.gradio-container {
+    max-width: 1200px !important;
+    margin: 0 auto !important;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+}
+
+#chatbot {
+    min-height: 500px;
+    border: 1px solid #e0e0e0;
+    border-radius: 8px;
+    margin-bottom: 20px;
+    padding: 20px;
+    background-color: #f9f9f9;
+}
+
+.user-message, .bot-message {
+    padding: 12px 16px;
+    border-radius: 18px;
+    margin: 8px 0;
+    max-width: 80%;
+    line-height: 1.5;
+}
+
+.user-message {
+    background-color: #007bff;
+    color: white;
+    margin-left: auto;
+    border-bottom-right-radius: 4px;
+}
+
+.bot-message {
+    background-color: #f1f1f1;
+    color: #333;
+    margin-right: auto;
+    border-bottom-left-radius: 4px;
+}
+
+#question-input textarea {
+    min-height: 50px !important;
+    border-radius: 8px !important;
+    padding: 12px !important;
+    font-size: 16px !important;
+}
+
+#send-button {
+    height: 100%;
+    background-color: #007bff !important;
+    color: white !important;
+    border: none !important;
+    border-radius: 8px !important;
+    font-weight: 500 !important;
+    transition: background-color 0.2s !important;
+}
+
+#send-button:hover {
+    background-color: #0056b3 !important;
+}
+
+.status-message {
+    text-align: center;
+    color: #666;
+    font-style: italic;
+    margin: 10px 0;
+}
+"""
+
+def create_ui():
+    """Crea y devuelve los componentes de la interfaz de usuario de Gradio."""
+    # Verificar el estado del entorno
+    env_ok, env_message = check_environment()
+    
+    # Crear el tema personalizado
+    theme = gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="indigo",
+        neutral_hue="slate"
+    )
+    
+    with gr.Blocks(
+        css=custom_css,
+        title="Asistente de Base de Datos SQL",
+        theme=theme
+    ) as demo:
+        # Encabezado
+        gr.Markdown("""
+        # 🤖 Asistente de Base de Datos SQL
+        
+        Haz preguntas en lenguaje natural sobre tu base de datos y obtén resultados de consultas SQL.
+        """)
+        
+        # Mensaje de estado
+        if not env_ok:
+            gr.Warning("⚠️ " + env_message)
+        
+        # Create the chat interface
+        with gr.Row():
+            chatbot = gr.Chatbot(
+                value=[],
+                elem_id="chatbot",
+                type="messages",  # migrate to messages format to avoid deprecation
+                avatar_images=(
+                    None,
+                    (os.path.join(os.path.dirname(__file__), "logo.svg")),
+                ),
+                height=600,
+                render_markdown=True,  # Enable markdown rendering
+                show_label=False,
+                show_share_button=False,
+                container=True,
+                layout="panel"  # Better layout for messages
+            )
+        
+        # Chart display area (interactive Plotly figure)
+        # In Gradio 5, gr.Plot accepts a plotly.graph_objects.Figure
+        chart_display = gr.Plot(
+            label="📊 Visualización",
+        )
+        
+        # Input area
+        with gr.Row():
+            question_input = gr.Textbox(
+                label="",
+                placeholder="Escribe tu pregunta aquí...",
+                container=False,
+                scale=5,
+                min_width=300,
+                max_lines=3,
+                autofocus=True,
+                elem_id="question-input"
+            )
+            submit_button = gr.Button(
+                "Enviar",
+                variant="primary",
+                min_width=100,
+                scale=1,
+                elem_id="send-button"
+            )
+        
+        # System status
+        with gr.Accordion("ℹ️ Estado del sistema", open=not env_ok):
+            if not DEPENDENCIES_AVAILABLE:
+                gr.Markdown("""
+                ## ❌ Dependencias faltantes
+                
+                Para ejecutar esta aplicación localmente, necesitas instalar las dependencias:
+                
+                ```bash
+                pip install -r requirements.txt
+                ```
+                """)
+            else:
+                if not agent:
+                    gr.Markdown(f"""
+                    ## ⚠️ Configuración incompleta
+                    
+                    No se pudo inicializar el agente de base de datos. Por favor, verifica que:
+                    
+                    1. Todas las variables de entorno estén configuradas correctamente
+                    2. La base de datos esté accesible
+                    3. La API de Google Gemini esté configurada
+                    
+                    **Error:** {agent_error if agent_error else 'No se pudo determinar el error'}
+                    
+                    ### Configuración local
+                    
+                    Crea un archivo `.env` en la raíz del proyecto con las siguientes variables:
+                    
+                    ```
+                    DB_USER=tu_usuario
+                    DB_PASSWORD=tu_contraseña
+                    DB_HOST=tu_servidor
+                    DB_NAME=tu_base_de_datos
+                    GOOGLE_API_KEY=tu_api_key_de_google
+                    ```
+                    """)
+                else:
+                    if os.getenv('SPACE_ID'):
+                        # Modo demo en Hugging Face Spaces
+                        gr.Markdown("""
+                        ## 🚀 Modo Demo
+                        
+                        Esta es una demostración del asistente de base de datos SQL. Para usar la versión completa con conexión a base de datos:
+                        
+                        1. Clona este espacio en tu cuenta de Hugging Face
+                        2. Configura las variables de entorno en la configuración del espacio:
+                           - `DB_USER`: Tu usuario de base de datos
+                           - `DB_PASSWORD`: Tu contraseña de base de datos
+                           - `DB_HOST`: La dirección del servidor de base de datos
+                           - `DB_NAME`: El nombre de la base de datos
+                           - `GOOGLE_API_KEY`: Tu clave de API de Google Gemini
+                        
+                        **Nota:** Actualmente estás en modo de solo demostración.
+                        """)
+                    else:
+                        gr.Markdown("""
+                        ## ✅ Sistema listo
+                        
+                        El asistente está listo para responder tus preguntas sobre la base de datos.
+                        """)
+        
+        # Hidden component for streaming output
+        streaming_output_display = gr.Textbox(visible=False)
+        
+        return demo, chatbot, chart_display, question_input, submit_button, streaming_output_display
 
 def create_application():
     """Create and configure the Gradio application."""
     # Create the UI components
     demo, chatbot, chart_display, question_input, submit_button, streaming_output_display = create_ui()
     
-    # Montar la API Flask en la aplicación Gradio
-    if os.getenv('SPACE_ID'):
-        demo = gr.mount_gradio_app(
-            flask_app,
-            "/api",  # Prefijo para los endpoints de la API
-            lambda: True  # Autenticación deshabilitada
-        )
-    
     def user_message(user_input: str, chat_history: List[Dict[str, str]]) -> Tuple[str, List[Dict[str, str]]]:
         """Add user message to chat history (messages format) and clear input."""
         if not user_input.strip():
@@ -81,6 +1034,37 @@ def create_application():
             # Append assistant message back into messages history
             chat_history.append({"role": "assistant", "content": assistant_message})
 
+            # If user asked for a chart but none was produced, try to build one
+            # from the latest assistant text using the same fallback logic.
+            if chart_fig is None:
+                wants_chart, desired_type = detect_chart_preferences(question)
+                if wants_chart and isinstance(assistant_message, str):
+                    candidate_text = assistant_message
+                    raw_lines = candidate_text.split('\n')
+                    norm_lines = []
+                    for l in raw_lines:
+                        s = l.strip().lstrip("•*\t -")
+                        if s:
+                            norm_lines.append(s)
+                    data = []
+                    for l in norm_lines:
+                        m = re.match(r"^(.+?):\s*([0-9][0-9.,]*)$", l)
+                        if m:
+                            label = re.sub(r"[*_`]+", "", m.group(1)).strip()
+                            try:
+                                val = float(m.group(2).replace(',', ''))
+                            except Exception:
+                                continue
+                            data.append({"label": label, "value": val})
+                    if len(data) >= 2:
+                        chart_fig = generate_chart(
+                            data=data,
+                            chart_type=desired_type,
+                            x="label",
+                            y="value",
+                            title="Distribución"
+                        )
+
             logger.info("Response generation complete")
             return chat_history, chart_fig
 

requirements.txt

@@ -15,4 +15,3 @@ python-multipart>=0.0.18  # Required by gradio
 plotly==5.18.0  # For interactive charts
 kaleido==0.2.1  # For saving plotly charts as images
 tabulate>=0.9.0  # Enables DataFrame.to_markdown used for chart parsing
-flask>=2.0.0  # Required for API endpoints