Return DB-free runtime identity, registered-tool capabilities, and contract fingerprints for this MCP server process.

List the configured Azure SQL databases available to this MCP server.

Probe Azure SQL capabilities and permission-sensitive features for a database.

List schemas in the selected Azure SQL database.

List objects in a schema. Supports table, view, procedure, function, and index.

Search for database objects by name pattern across all schemas.

Show detailed information about a schema object.

Get dependency graph for a database object: what it references and what references it.

Get approximate row counts and storage sizes for tables.

Capture a point-in-time schema snapshot for a database.

Compare schemas between two databases and return all differences.

Generate a T-SQL migration script to transform source schema to match target.

List active sessions and running queries, including blocking information.

Execute statically validated, row-capped read-only SQL. The query may be preceded by DECLARE @var and SET @var = ... statements, followed by exactly one SELECT. DML, DDL, dynamic SQL, and stored procedure execution are always rejected.

Generate an estimated or actual execution plan for a read-only SQL query.

Compatibility initializer only: open a performance case/session and collect evidence. It does not generate or benchmark a rewrite and must not be treated as a completed optimization. Named optimizer profiles use the explicit case/session workflow instead.

Benchmark a baseline query against a proposed rewrite using the same typed read-only execution path, interleaved actual-plan samples, and complete bounded snapshot equivalence.

Analyze direct SQL and recursively resolved view definitions for semantic-equivalence proof risks without returning raw definitions.

Create a durable, redacted performance case. SQL is fingerprinted and is not written to the MCP state database.

Collect Azure SQL resource, Query Store, wait, blocking, statistics, parameter-sensitivity, and regression evidence for a performance case.

Get a redacted performance case, its evidence envelopes, and event history.

Start a durable iterative tuning session. Defaults are 10 candidates, 80 executions, and 20 minutes; explicit multi-hour budgets are accepted when the local database policy permits them.

Resume a durable tuning session with its complete redacted leaderboard, evidence, events, and remaining budgets. Raw SQL is never persisted.

Add one concrete rewrite or index experiment to a tuning session. Only its fingerprint and optional artifact reference are persisted.

Benchmark one rewrite candidate with interleaved, exactly-once samples and snapshot-consistent duplicate-aware result comparison.

Benchmark a leased disposable index in a policy-allowlisted sandbox. Cleanup is automatic and cleanup failures are durable.

Finalize a tuning session with the winning candidate, complete leaderboard, rejected experiments, and explicit stopping reason.

Compare two read-only query results in one snapshot. The result is proven only when the complete bounded results, duplicates, shape, and required order match.

Compare arbitrary redacted execution-plan summaries and sourced metrics.

Prepare and preview a reversible CREATE VIEW or ALTER VIEW change. Optimizer preparations are process-local previews; sandbox preparations become restart-safe only with explicit raw-SQL state opt-in.

List top queries from Query Store.

Extract SQL Server missing-index hints from estimated plans for up to 10 queries. A per-query missing_index_count of zero means no Showplan hint was emitted for that plan. The filtered recommendations can also be empty when an existing index already covers an emitted hint; neither condition proves that no index could improve the query.

Analyze the database workload to identify resource-intensive queries and recommend optimal indexes.

Analyze missing-index and automatic tuning recommendations.

Run the index optimization engine: analyzes workload from Query Store, generates index candidates from execution plans and DMVs, estimates sizes, scores using Pareto optimization (read benefit vs size vs write overhead), and returns budget-constrained ranked recommendations.

Get top wait statistics from sys.dm_db_wait_stats with category mapping (CPU, I/O, Lock, Memory, Network, etc.), benign wait filtering, and root-cause recommendations.

Get per-query wait breakdown from Query Store wait stats. Ties waits to specific queries: 'this query is slow because of X'.

Get currently waiting tasks right now — real-time view of what is blocked from sys.dm_os_waiting_tasks with SQL text and wait category.

Get current lock details from sys.dm_tran_locks with owning session, lock mode (S, X, IX, IS, U, Sch-M), resource type, and SQL text.

Get open transactions with duration, type (read/write, read-only), log bytes used, and warnings for long-running or idle-in-transaction.

Get recent deadlock history from system_health extended events session. Parses deadlock XML to show victim, participants, resources, and SQL text.

Get per-session tempdb consumption: user/internal object allocations and net usage in MB.

Get tempdb space breakdown: version store, user objects, internal objects, free space. Useful for diagnosing version store bloat under snapshot isolation.

Get active and pending memory grants. Identifies queries waiting for memory (RESOURCE_SEMAPHORE) and queries likely spilling to tempdb.

Get MCP server connection pool statistics: per-database acquire/release/discard counts, peak utilization, and possible connection leaks. Diagnoses MCP-side slowness without touching the database.

Get per-file I/O stats: read/write latency, throughput, stall times. Warns when average latency exceeds 20ms threshold.

Get Azure resource governance limits: max CPU%, IOPS, log rate, memory, workers, and current service tier/objective.

Get resource utilization history (15-sec granularity) from sys.dm_db_resource_stats. Shows CPU, data I/O, log write, memory trends with sustained pressure warnings.

Get Azure SQL database configuration inventory: version, read-only instance settings, database properties, scoped configurations, Query Store, automatic tuning, geo-replication links, and Azure DB properties.

Get Azure SQL storage diagnostics: database/file size, log usage, VLF counts, last VLF status, and high-usage warnings.

Get connection diagnostics: connection counts by client IP, session summary, and optional bounded input-buffer text for current database sessions.

Get top cached statements from sys.dm_exec_query_stats. Returns bounded text previews and plan-cache metrics without raw plan XML.

Get cached stored procedure and UDF execution statistics. Returns bounded routine metrics and missing-index flags without raw plan XML.

Get object and index diagnostics: write-heavy nonclustered indexes, read/write usage, buffer footprint, volatile stats, columnstore row groups, index lock waits, and resumable index rebuilds.

Check statistics health: stale stats, high modification counts, low sample rates. Flags stats needing UPDATE STATISTICS.

Analyze plan cache: plan type distribution, single-use plan bloat, top plans by size. Detects ad-hoc query pollution.

Identify excessively recompiled queries from sys.dm_exec_query_stats. Flags queries where recompile ratio exceeds 50%.

Detect parameter sniffing: queries with multiple plans where MAX(avg_duration) / MIN(avg_duration) exceeds threshold (default 10x).

Surface automatic tuning regression recommendations from sys.dm_db_tuning_recommendations with plan forcing scripts.

Compare two query plans side-by-side: operators, duration, CPU, I/O. If plan IDs not specified, compares best vs worst plan by duration.

List all forced plans with execution stats and staleness warnings. Identifies forced plans that haven't executed recently or have force failures.

Extract the compiled parameter values behind each Query Store plan for one query — the parameter buckets a tuning pass must test. Each distinct compiled set produced its own plan shape in production; pair with boundary/NULL/empty cases the history cannot show.

Review Query Store health, parameter sensitivity, regressions, forced-plan failures, and ranked force/unforce candidates.

Preview one plan-enforcement cycle. This tool is permanently read-only; use the prepared plan-action workflow for reviewed mutations.

Review Query Store regressions and forced-plan health, then rank read-only candidate plan force/unforce actions.

Preview an exact reversible Query Store force/unforce action and record an audit entry without executing it.

Capture exact Query Store control state and persist a reviewed, redacted plan-action intent. Automatic Tuning ownership is review-only.

Analyze operational Azure SQL database health. Query-performance triage belongs to collect_performance_evidence, which uses resource, Query Store, wait, blocking, statistics, parameter-sensitivity, and regression evidence.

Record a redacted skill decision backed by scoped evidence. Learning is advisory and cannot change database activity.

Review one decision using only MCP-created terminal-link evidence.

Propose an inactive lesson from reviewed decisions.

Recall at most three fresh, active, scoped lessons.

List deterministic lesson candidates for maintainer review.

Create a durable, redacted cross-skill learning handoff.

Read one scoped durable cross-skill learning handoff.

Claim, resolve, reopen, or cancel a scoped learning handoff; successful resolutions can link a decision.