import os import sys import re import gradio as gr import json import tempfile import base64 import io from typing import List, Dict, Any, Optional, Tuple, Union import logging 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 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() 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(): return "", chat_history logger.info(f"User message: {user_input}") if chat_history is None: chat_history = [] # Append user message in messages format chat_history.append({"role": "user", "content": user_input}) return "", chat_history async def bot_response(chat_history: List[Dict[str, str]]) -> Tuple[List[Dict[str, str]], Optional[go.Figure]]: """Generate bot response for messages-format chat history and return optional chart figure.""" if not chat_history: return chat_history, None # Ensure last message is a user turn awaiting assistant reply last = chat_history[-1] if not isinstance(last, dict) or last.get("role") != "user" or not last.get("content"): return chat_history, None try: question = last["content"] logger.info(f"Processing question: {question}") # Convert prior messages to pair history for stream_agent_response() pair_history: List[List[str]] = [] i = 0 while i < len(chat_history) - 1: m1 = chat_history[i] m2 = chat_history[i + 1] if i + 1 < len(chat_history) else None if ( isinstance(m1, dict) and m1.get("role") == "user" and isinstance(m2, dict) and m2.get("role") == "assistant" ): pair_history.append([m1.get("content", ""), m2.get("content", "")]) i += 2 else: i += 1 # Call the agent for this new user question assistant_message, chart_fig = await stream_agent_response(question, pair_history) # 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 except Exception as e: error_msg = f"## ❌ Error\n\nError al procesar la solicitud:\n\n```\n{str(e)}\n```" logger.error(error_msg, exc_info=True) # Ensure we add an assistant error message for the UI chat_history.append({"role": "assistant", "content": error_msg}) return chat_history, None # Event handlers with demo: # Handle form submission msg_submit = question_input.submit( fn=user_message, inputs=[question_input, chatbot], outputs=[question_input, chatbot], queue=True ).then( fn=bot_response, inputs=[chatbot], outputs=[chatbot, chart_display], api_name="ask" ) # Handle button click btn_click = submit_button.click( fn=user_message, inputs=[question_input, chatbot], outputs=[question_input, chatbot], queue=True ).then( fn=bot_response, inputs=[chatbot], outputs=[chatbot, chart_display] ) return demo # Create the application demo = create_application() # Configuración para Hugging Face Spaces def get_app(): """Obtiene la instancia de la aplicación Gradio para Hugging Face Spaces.""" # Verificar si estamos en un entorno de Hugging Face Spaces if os.getenv('SPACE_ID'): # Configuración específica para Spaces demo.title = "🤖 Asistente de Base de Datos SQL (Demo)" demo.description = """ Este es un demo del asistente de base de datos SQL. Para usar la versión completa con conexión a base de datos, clona este espacio y configura las variables de entorno. """ return demo # Para desarrollo local if __name__ == "__main__": # Configuración para desarrollo local - versión simplificada para Gradio 5.x demo.launch( server_name="0.0.0.0", server_port=7860, debug=True, share=False )