API solved

README.md

@@ -19,11 +19,104 @@ 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
-2. Install dependencies: `pip install -r requirements.txt`
-3. Run the app: `python app.py`
+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"}'
+```
 
 Check out the [configuration reference](https://huggingface.co/docs/hub/spaces-config-reference) for more options.

api.py

@@ -0,0 +1,103 @@
+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,976 +12,23 @@ import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
-try:
-    from sqlalchemy import text as sa_text
-except Exception:
-    sa_text = None
+from api import app as flask_app
 
-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
+# ... (resto del código existente sin cambios) ...
 
 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():
@@ -1034,37 +81,6 @@ 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,3 +15,4 @@ 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