AskDB: Unified LLM Database Interface

• AskDB is an LLM-based agent that unifies natural language query translation for both analytical and administrative database tasks in a single interface.
• It employs dynamic schema-aware prompting and a ReAct agent loop to ground queries, execute multi-step SQL debugging, and optimize performance.
• The system bridges the human–database gap by enabling non-expert users to access complex relational data while streamlining DBA routines.

AskDB is a LLM-based agent that provides a unified conversational interface for both analytical queries and administrative operations on relational databases. Designed to bridge the gap between SQL-expert users and those lacking technical database skills, AskDB leverages advances in LLMs, dynamic schema-aware prompting, and automated agentic planning to support natural language interaction across a spectrum of database scenarios, including complex analysis, debugging, and system administration (Phan et al., 20 Nov 2025).

1. Motivating Challenges and Design Objectives

The fundamental challenge AskDB addresses is the human–database divide: business analysts and other end users frequently require access to complex information locked in SQL databases but often lack the necessary query language expertise. Simultaneously, Database Administrators (DBAs) expend significant effort on routine maintenance rather than optimization and security. Existing systems generally silo natural language interfaces (NL2SQL) from administration functionalities—inhibiting a holistic, conversational experience. AskDB’s design objectives are:

• Unification of analytical (NL2SQL) and administrative (DBA) capabilities in a single agentic interface.
• Automated grounding of user queries against arbitrary database schemas.
• Multi-step task planning for operations ranging from SQL debugging to performance tuning and security tasks.
• Safety via risk classification and human-in-the-loop confirmation for high-risk operations.

2. System Architecture and Operational Framework

AskDB is built upon Google’s Gemini 2.0 Flash and Gemini 2.5 Flash LLMs, yielding a cost-efficient solution (sub-\$0.15/\$0.60 per 1M tokens) with competitive analytical reasoning. The system pipeline consists of:

• ReAct Agent Loop: AskDB follows a Reason → Act → Observe cycle, in which the LLM reasons about the current goal and context, selects an action (including tool invocation), observes the outcome, and iteratively refines its strategy. The core pseudocode is:

function AskDB_Agent(user_query): history ← [] observation ← None while True: prompt ← assemble_prompt(user_query, history, observation) thought_action ← LLM.generate(prompt) if thought_action.type == "respond": return thought_action.text else: # action = (tool_name, args) observation ← call_tool(thought_action.tool, thought_action.args) history.append((thought_action, observation))

Supported tools include SQL execution (execute_query, execute_non_query), semantic table lookup (search_tables_by_name), and on-demand web search (request_for_internet_search).

• Dynamic Schema-Aware Prompting: To cope with large schemas, AskDB employs a retrieval-augmented mechanism that scopes schema information to only query-relevant tables and columns. Salient steps comprise named-entity recognition in the NL query, semantic similarity ranking of tables via embedded vectors:

$$s_i = \mathrm{cosine}(e_q, e_{t_i}) = \frac{e_q^\top e_{t_i}}{\|e_q\|\; \|e_{t_i}\|}$$

The top-$K$ tables are then summarized as a Markdown schema block and injected into the LLM prompt.

• Task Decomposition and Planning: Complex workflows are recursively decomposed into sequences of tool calls, using LLM-driven thought-action parsing. Plans are executed stepwise, with chain-of-thought context maintained to support error correction and mid-task replanning.

3. Principal Functionalities

AskDB’s agentic capabilities encompass:

• Natural Language Analytical Querying: End-to-end translation of NL queries into SQL via dynamic schema prompting, enabling users to retrieve, explore, and summarize data across arbitrary relational datasets.
• Autonomous SQL Debugging: When query execution errors occur, the agent receives the detailed error as an observation, diagnoses root causes (e.g., syntax, schema mismatch, missing clauses), and iteratively proposes corrected SQL until success or cutoff.
• Administrative Operations: Commands and playbooks for database administration—including user management, backups, access grants/revokes, and index recommendations—are mapped to planned action sequences, with risk classification gates for sensitive operations requiring explicit user approval.
• Real-Time Web Search and Context Grounding: For ambiguous or domain-specific questions, external documentation or context (e.g., compliance standards) is incorporated via on-demand web search; summarized snippets are included in the agent’s prompt for enhanced grounding.
• Adaptive Response Refinement: Feedback-driven iteration, both implicit (user clarifies query) and explicit (“That’s not right”), triggers the agent to refine SQL logic, explanations, or recommended actions.

4. Experimental Results and Evaluation

AskDB underwent empirical evaluation on standard benchmarks and curated DBA scenarios. Metrics and findings include:

Task Suite	Execution Accuracy	Avg. Turns	Success Rate	Cost Per 1M Tokens
Spider 1.0 (subset)	89.8%	1.45	N/A	\$0.15 (input), \$0.60 (output)
Spider 2.0-Lite	36.31%	1.34	N/A	\$0.15/\$0.60
DBA Task Suite (15)	N/A	N/A	93%	N/A

• Spider 1.0 results indicate parity or outperformance relative to leading alternatives (DAIL-SQL (GPT-4): 86.2%, C3 (GPT-3.5): 82.3%).
• On complex Spider 2.0-Lite (nested queries, cross-dialect), a 36.31% execution accuracy reflects current LLMs’ remaining limitations with advanced SQL constructs.
• DBA tasks achieved 93% success rate in full automation, with an average confirmation count of 0.8 per task.

Ablation analysis demonstrates that disabling dynamic schema selection reduces execution accuracy by $\approx 7\%$, and omitting the ReAct correction loop lowers accuracy by $\approx 5\%$ and increases the required number of interactive turns. In stress testing, omitting guardrail playbooks resulted in uncontrolled destructive actions (Phan et al., 20 Nov 2025).

5. Illustrative Use Cases

Several canonical interactions exemplify AskDB’s breadth:

• Analytical Query: "Show me all customers who have placed more than five orders in the last year."
  • Multi-step plan: table search, schema injection, SQL generation, execution, and tabular/narrative result return.
• Administrative Task: "Archive logs older than six months."
  • Classified as high-risk; agent drafts an action plan (backup, delete), presents for confirmation, and executes after approval.
• Performance Tuning: "Why is my orders query so slow?"
  • Executes EXPLAIN, interprets result (e.g., full table scans), proposes and applies indexes with user approval, and verifies subsequent performance improvements.

6. Limitations and Prospective Advancements

Observed limitations of AskDB include:

• Reduced accuracy and resilience on deeply nested queries and advanced SQL constructs (notably window functions, complex CTEs), as quantified by Spider 2.0-Lite results.
• System dependence on Gemini models; cross-LLM portability remains to be validated.
• Current safety guardrails rely on heuristic playbooks; semantic PII detection is not exhaustive and may miss edge cases (Phan et al., 20 Nov 2025).

Planned improvements comprise:

• Integration of specialized SQL planning or program analysis modules to handle complex patterns.
• Development of a model-agnostic interface and support for multi-model orchestration.
• Expansion of the DBA playbook library to better support compliance and enterprise governance requirements (e.g., GDPR, HIPAA).
• Comprehensive live ablation and A/B testing in deployed environments to quantify user satisfaction, trust, and error resilience.

7. Broader Implications and Related Work

AskDB provides a principled demonstration of unified conversational agents capable of performing analytical and administrative tasks over databases. Dynamic schema-aware prompting is highlighted as a generalizable technique for efficiently grounding LLMs in external structured knowledge. As guardrails are further matured and model interfaces expanded, such agentic systems are anticipated to become standard database co-pilots across enterprise IT ecosystems. Comparatively, related systems such as AskYourDB focus on end-to-end NL2SQL translation and automatic visualization but do not integrate administrative operations or flexible agentic planning (Phan et al., 20 Nov 2025, Joseph et al., 2022).