Database Operations

An exec call carrying a command that crosses into a pod container to run psql and redis-cli shells, returning a table-size report and a Redis memory stat as evidence

The exec endpoint isn’t just for running echo hello. Agents use it to interact with databases, caches, and any CLI tool running inside a container, turning natural language into actual application-level operations.

PostgreSQL: Table size report

An agent asked “what’s the largest table in my Postgres?” runs psql inside the container:

async () => {
  const clusterId = "cls_abc123"; // resolved by the agent from conversation

  const res = await platform.request({
    method: "POST",
    path: `/v1/clusters/${clusterId}:exec`,
    body: {
      namespace: "default",
      pod: "postgres-0",
      container: "postgresql",
      command: ["psql", "-U", "postgres", "-c", `
        SELECT schemaname, tablename,
               pg_size_pretty(pg_total_relation_size(schemaname || '.' || tablename)) AS total_size,
               pg_size_pretty(pg_relation_size(schemaname || '.' || tablename)) AS data_size,
               pg_size_pretty(pg_indexes_size(schemaname || '.' || quote_ident(tablename))) AS index_size,
               n_live_tup AS row_count
        FROM pg_stat_user_tables
        ORDER BY pg_total_relation_size(schemaname || '.' || tablename) DESC
        LIMIT 15;
      `]
    }
  });
  return res.body;
}

The agent gets back formatted SQL output with table sizes, index sizes, and row counts. It can then reason about which tables need vacuuming, which indexes are bloated, or whether a migration is needed.

Redis: Memory analysis

async () => {
  const clusterId = "cls_abc123"; // resolved by the agent from conversation

  const info = await platform.request({
    method: "POST",
    path: `/v1/clusters/${clusterId}:exec`,
    body: {
      namespace: "default",
      pod: "redis-0",
      container: "redis",
      command: ["redis-cli", "INFO", "memory"]
    }
  });

  const stats = await platform.request({
    method: "POST",
    path: `/v1/clusters/${clusterId}:exec`,
    body: {
      namespace: "default",
      pod: "redis-0",
      container: "redis",
      command: ["redis-cli", "INFO", "keyspace"]
    }
  });

  return { memory: info.body.output, keyspace: stats.body.output };
}

Chaining queries

The agent can chain multiple queries in a single execution, checking replication lag and then inspecting the slowest queries:

async () => {
  const clusterId = "cls_abc123"; // resolved by the agent from conversation

  const exec = (command) => platform.request({
    method: "POST",
    path: `/v1/clusters/${clusterId}:exec`,
    body: {
      namespace: "default",
      pod: "postgres-0",
      container: "postgresql",
      command: ["psql", "-U", "postgres", "-t", "-A", "-c", command]
    }
  }).then(r => r.body.output.trim());

  const [replLag, slowQueries, connCount, dbSize] = await Promise.all([
    exec("SELECT CASE WHEN pg_is_in_recovery() THEN extract(epoch FROM now() - pg_last_xact_replay_timestamp())::int || 's' ELSE 'primary' END"),
    exec("SELECT query, calls, mean_exec_time::int || 'ms' FROM pg_stat_statements ORDER BY mean_exec_time DESC LIMIT 5"),
    exec("SELECT count(*) FROM pg_stat_activity WHERE state = 'active'"),
    exec("SELECT pg_size_pretty(pg_database_size(current_database()))"),
  ]);

  return { replication_lag: replLag, slow_queries: slowQueries, active_connections: connCount, database_size: dbSize };
}

Four psql queries in parallel: replication lag, slowest queries, active connections, database size. All from one execute call.

Why this matters

Database operations through traditional MCP tools would need a dedicated tool per database type (postgres-query, redis-info, mongo-stats), each with their own schema, parameters, and maintenance burden. With exec + Code Mode, the agent writes the exact command it needs. It knows psql flags, redis-cli subcommands, and mongosh syntax from its training data. No pre-built tools required. The agent composes the right command for any database, any query.

Exec is non-interactive with a 30-second timeout. It’s ideal for read queries and diagnostics. For long-running operations or interactive sessions, use the dashboard terminal.

Full-stack dashboard in minutes

Combine database exec queries with cluster health in one dashboard.

Kubernetes access

The exec endpoint request and response shape.

Incident debugging

Adaptive SRE triage using pod health, events, and logs.

Code Mode in action

How agents chain multiple operations in one call.

Overview

MCP Servers

Guides

Examples

PostgreSQL: Table size report

Redis: Memory analysis

Chaining queries

Why this matters

Full-stack dashboard in minutes

Kubernetes access

Incident debugging

Code Mode in action

​PostgreSQL: Table size report

​Redis: Memory analysis

​Chaining queries

​Why this matters

​Related topics

Full-stack dashboard in minutes

Kubernetes access

Incident debugging

Code Mode in action

PostgreSQL: Table size report

Redis: Memory analysis

Chaining queries

Why this matters

Related topics