====== Database Tuning Agents ======

LLM-guided autonomous database tuning combines the semantic reasoning capabilities of large language models with reinforcement learning for configuration optimization, achieving rapid convergence and cross-workload transferability.

===== Overview =====

Modern database management systems expose hundreds of tunable configuration parameters (knobs) that control memory allocation, query execution, logging, and concurrency. The interdependencies among these knobs make manual tuning by database administrators (DBAs) laborious and prone to suboptimal outcomes. L2T-Tune(([[https://arxiv.org/abs/2511.01602|Yang et al. "L2T-Tune: LLM-Guided Hybrid Database Tuning with LHS and TD3." arXiv:2511.01602, 2025.]])) introduces a three-stage hybrid pipeline combining LLM semantic reasoning with TD3 reinforcement learning, while AskDB(([[https://arxiv.org/abs/2511.16131|"AskDB: Autonomous Database Administration with LLM Agents." arXiv:2511.16131, 2025.]])) explores conversational LLM interfaces for autonomous database administration.

===== L2T-Tune: LLM-Guided Hybrid Tuning =====

L2T-Tune proposes a three-stage pipeline that synergistically combines sampling-based exploration, LLM-guided semantic reasoning, and RL-based fine-tuning.

**Stage 1: LHS Warm-Start for Diverse Exploration**

Latin Hypercube Sampling (LHS) generates uniform samples across the high-dimensional knob space. For MySQL with $d = 266$ tunable knobs, $n = 120$ normalized action vectors are generated:

<latex>\mathbf{A}^{(j)} \in [0, 1]^{266}, \quad j = 1, \ldots, 120</latex>

Each action vector is mapped to physical knob settings under trust-region constraints. The performance fitness function is:

<latex>f = rac{	ext{TPS}}{p_{95}	ext{-latency}}</latex>

Data is stored as tuples $(S, A, P)$ where $S$ is state, $A$ is action (configuration), and $P$ is performance.

**Stage 2: LLM-Guided Semantic Reasoning**

A large language model mines and prioritizes tuning hints from database manuals and community documentation. The LLM extracts domain knowledge to narrow the search space and provides warm-start guidance for the RL phase.

**Stage 3: TD3 Reinforcement Learning Fine-Tuning**

The Twin Delayed Deep Deterministic Policy Gradient (TD3) algorithm fine-tunes configurations using the warm-start sample pool for dimensionality reduction:

<latex>Q(s, a) \leftarrow Q(s, a) + lpha \left[ r + \gamma \min_{i=1,2} Q_{	heta'_i}(s', \pi_{\phi'}(s')) - Q(s, a) 
ight]</latex>

TD3 uses twin critics to reduce overestimation bias, delayed policy updates, and target policy smoothing for stable convergence.

===== AskDB: Conversational Database Administration =====

AskDB provides a natural-language interface for database administration tasks. The system allows DBAs to query system tables (e.g., ''information_schema'', ''performance_schema'') conversationally, receiving tuning recommendations, diagnostic insights, and optimization suggestions through an LLM-powered agent that decomposes queries into executable SQL steps.

===== Code Example =====

<code python>
import numpy as np
from scipy.stats import qmc

class L2TTuner:
    def __init__(self, n_knobs: int = 266, n_samples: int = 120):
        self.n_knobs = n_knobs
        self.n_samples = n_samples
        self.sample_pool: list[tuple] = []

    def lhs_warm_start(self) -> np.ndarray:
        sampler = qmc.LatinHypercube(d=self.n_knobs)
        actions = sampler.random(n=self.n_samples)
        return actions

    def evaluate_config(self, config: dict) -> float:
        tps = self.run_benchmark(config)
        p95_latency = self.measure_p95(config)
        fitness = tps / max(p95_latency, 1e-6)
        self.sample_pool.append((
            self.get_db_state(), config, fitness
        ))
        return fitness

    def llm_guided_search(self, manual_text: str,
                          current_config: dict) -> dict:
        hints = self.llm.extract_tuning_hints(manual_text)
        prioritized = self.llm.prioritize_knobs(
            hints, current_config, self.sample_pool
        )
        return self.apply_hints(current_config, prioritized)

    def td3_fine_tune(self, n_steps: int = 30):
        state = self.get_db_state()
        for step in range(n_steps):
            action = self.td3_policy(state)
            config = self.action_to_config(action)
            reward = self.evaluate_config(config)
            next_state = self.get_db_state()
            self.td3_update(state, action, reward, next_state)
            state = next_state
</code>

===== Architecture =====

<mermaid>
graph TD
    A[Database Workload] --> B[Stage 1: LHS Warm-Start]
    B --> C[Sample Pool - S A P tuples]
    C --> D[Stage 2: LLM Reasoning]
    D --> E[Database Manuals]
    D --> F[Community Docs]
    E --> G[Knob Prioritization]
    F --> G
    G --> H[Dimensionality Reduction]
    C --> H
    H --> I[Stage 3: TD3 RL Fine-Tuning]
    I --> J[Twin Critics Q1 Q2]
    I --> K[Delayed Policy Updates]
    J --> L[Optimized Configuration]
    K --> L
    L --> M{Performance Target Met?}
    M -->|No| I
    M -->|Yes| N[Deploy Config]
    N --> O[Online Monitoring]
    O -->|Workload Shift| A
</mermaid>

===== Key Results =====

^ Metric ^ L2T-Tune ^ Best Alternative ^
| Avg improvement (all workloads) | +37.1% | Baseline |
| TPC-C improvement | +73% | Baseline |
| Online tuning convergence | 30 steps | Hundreds of steps |
| Offline convergence | Single server | Multi-server required |
| Warm-start method | LHS (uniform) | Random/GA (clustered) |

===== See Also =====

  * [[devops_incident_agents|DevOps Incident Agents]]
  * [[budget_aware_reasoning|Budget-Aware Reasoning]]
  * [[financial_trading_agents|Financial Trading Agents]]

===== References =====