diff --git a/docker-compose.cloud.yml b/docker-compose.cloud.yml
index e6c845c7d..7ede1078e 100644
--- a/docker-compose.cloud.yml
+++ b/docker-compose.cloud.yml
@@ -87,6 +87,15 @@ x-backend: &backend
     - SENTRY_ENVIRONMENT=${SENTRY_ENVIRONMENT:-production}
     - SENTRY_TRACES_SAMPLE_RATE=${SENTRY_TRACES_SAMPLE_RATE:-0.05}
     - SENTRY_VERIFY_TOKEN=${SENTRY_VERIFY_TOKEN:-}
+    # Prometheus /metrics — a separate listener, off by default (docs/operations/observability.md).
+    # METRICS_TOKEN is required once METRICS_ENABLED=true; the listener refuses to start without it.
+    # METRICS_TOOL_LABELS is always ignored here regardless of its value — no series may carry a
+    # connector id or tool name across tenant workspaces.
+    - METRICS_ENABLED=${METRICS_ENABLED:-false}
+    - METRICS_PORT=${METRICS_PORT:-9464}
+    - METRICS_HOST=${METRICS_HOST:-0.0.0.0}
+    - METRICS_TOKEN=${METRICS_TOKEN:-}
+    - METRICS_TOOL_LABELS=${METRICS_TOOL_LABELS:-false}
     - NEXT_PUBLIC_API_URL=https://${DOMAIN}
     - DATABASE_URL=postgresql://amcp:${POSTGRES_PASSWORD}@postgres:5432/anythingmcp
     - REDIS_URL=redis://redis:6379
diff --git a/docker-compose.yml b/docker-compose.yml
index 68ffb68fc..b31342d81 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -110,6 +110,13 @@ services:
       - OPENAI_API_KEY=${OPENAI_API_KEY:-}
       - OPENROUTER_API_KEY=${OPENROUTER_API_KEY:-}
       - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY:-}
+      # Prometheus /metrics — a separate listener, off by default (docs/operations/observability.md).
+      # METRICS_TOKEN is required once METRICS_ENABLED=true; the listener refuses to start without it.
+      - METRICS_ENABLED=${METRICS_ENABLED:-false}
+      - METRICS_PORT=${METRICS_PORT:-9464}
+      - METRICS_HOST=${METRICS_HOST:-0.0.0.0}
+      - METRICS_TOKEN=${METRICS_TOKEN:-}
+      - METRICS_TOOL_LABELS=${METRICS_TOOL_LABELS:-false}
 
     depends_on:
       postgres:
diff --git a/docs/deployment.md b/docs/deployment.md
index fafbdd84e..53d172041 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -359,6 +359,11 @@ curl -s http://localhost:4000/api/mcp-api-keys \
 | `DOMAIN` | No | Domain for Caddy SSL certificate (e.g., `example.com`) |
 | `ACME_EMAIL` | No | Email for Let's Encrypt certificate notifications |
 | `APP_BIND_IP` | No | Bind IP for app ports (default: `0.0.0.0`, set `127.0.0.1` behind Caddy) |
+| `METRICS_ENABLED` | No | Start a second, separate `/metrics` listener for Prometheus (default: `false`) — see [observability.md](operations/observability.md) |
+| `METRICS_PORT` | No | Port for the metrics listener (default: `9464`) |
+| `METRICS_HOST` | No | Bind host for the metrics listener (default: `0.0.0.0`) |
+| `METRICS_TOKEN` | **Required when `METRICS_ENABLED=true`** | Bearer token required to scrape `/metrics`, compared with `timingSafeEqual` |
+| `METRICS_TOOL_LABELS` | No | Add `connector_id`/`tool` labels to tool-call metrics (default: `false`; ignored on Cloud) |
 
 ---
 
diff --git a/docs/operations/observability.md b/docs/operations/observability.md
index 8d87b4746..4d249e72e 100644
--- a/docs/operations/observability.md
+++ b/docs/operations/observability.md
@@ -176,6 +176,41 @@ Use the *raw* request body, not a re-serialized JSON object, since re-serializin
 
 The webhook URL is validated with the same guard (`SSRF_GUARD`, private/loopback/metadata-address blocking) used for every other outbound call this app makes on a user's behalf, both when it's saved and again on every dispatch, and redirects are not followed. On AnythingMCP Cloud the URL must use `https`, and it ignores both the env (`SSRF_ALLOWED_HOSTS`) and the admin-editable SSRF allowlist, which name hosts only the platform may reach. On a self-hosted instance the operator's allowlist applies, so an internal Mattermost or Slack proxy can receive alerts.
 
+## 6. Prometheus metrics (opt-in)
+
+Off unless `METRICS_ENABLED=true`. When on, the backend starts a **second, separate `node:http` listener** for `/metrics` — it never shares the main app's port 4000, because `/health*` is proxied publicly on both Cloud and self-hosted (`deploy/cloud/Caddyfile`, [deployment.md](../deployment.md)), and `/metrics` must not be.
+
+| Env | Default | |
+|---|---|---|
+| `METRICS_ENABLED` | `false` | Starts the listener. |
+| `METRICS_PORT` | `9464` | Metrics listener port. |
+| `METRICS_HOST` | `0.0.0.0` | Metrics listener bind host — a Prometheus container needs to reach it over the compose network, so the port is deliberately **not** published in `docker-compose.yml`. |
+| `METRICS_TOKEN` | unset | **Required** `Authorization: Bearer` token, compared with `timingSafeEqual`, whenever `METRICS_ENABLED=true` — on Cloud and self-hosted alike. Without it the listener refuses to start and logs an error; the default bind host `0.0.0.0` would otherwise serve `/metrics` to anyone who can reach the host. |
+| `METRICS_TOOL_LABELS` | `false` | Adds `connector_id` (cuid, not name) and `tool` labels to the tool-call metrics. Self-hosted only — **always ignored on Cloud**, even if set, so no series can carry a connector or tool identity across tenant workspaces. |
+
+### Metrics (prefix `anythingmcp_`)
+
+- `tool_calls_total{connector_type,status}` — counter, `status` is `success` or `error`.
+- `tool_call_duration_seconds{connector_type,status}` — histogram, buckets from 0.05 s to 60 s (tool calls can run 20 s or more).
+- `tool_call_upstream_errors_total{connector_type,upstream_status_class}` — only incremented for an actual upstream error; `upstream_status_class` is `4xx` or `5xx`.
+- `tool_calls_in_flight`, `mcp_requests_in_flight`, `registered_tools` — gauges mirrored from the in-process `processGauges` singleton at scrape time (not polled on an interval).
+- The standard `prom-client` Node runtime metrics (`collectDefaultMetrics()`: event loop lag, heap, GC, etc.).
+
+### Sample Prometheus scrape config
+
+```yaml
+scrape_configs:
+  - job_name: anythingmcp
+    scheme: http
+    bearer_token: '<METRICS_TOKEN>'
+    static_configs:
+      - targets: ['app:9464']
+```
+
+### Cloud vs self-hosted
+
+On Cloud, metrics are instance-wide only: no series may carry an organization id, connector name, tool name or user, which is why `METRICS_TOOL_LABELS` has no effect there. Per-organization usage already exists in the database (`AuditService.getBreakdowns`) and is unaffected by this endpoint. On self-hosted, the operator who sets `METRICS_TOOL_LABELS=true` is the only consumer of their own instance's metrics, so per-connector/per-tool labels are allowed. `METRICS_TOKEN` is required on both: the listener's default bind host is `0.0.0.0`.
+
 ## Fatal crash reports (always on in the Docker image)
 
 A fatal V8 error, such as an out-of-memory abort, ends the backend before any JavaScript handler runs, so the log has no stack. `start.sh` therefore starts the backend with `--report-on-fatalerror`: on such a crash Node writes a diagnostic report (`report.<date>.<time>.<pid>...json`) with the native stack, heap spaces and resource usage, plus the JavaScript stack when V8 can still produce one. It goes to `HEAP_SNAPSHOT_DIR` (`/app/diagnostics` in the image, a volume on AnythingMCP Cloud), next to the heap snapshots. Environment variables are left out of the report (`--report-exclude-env`); a Node older than 22.13 cannot do that, so on such a build the report stays off. Self-hosted and Cloud behave the same; to keep the reports across container recreation on a self-hosted install, mount a volume at `/app/diagnostics`.
diff --git a/package-lock.json b/package-lock.json
index 4555f7984..4e253ab70 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -11814,6 +11814,12 @@
         "file-uri-to-path": "1.0.0"
       }
     },
+    "node_modules/bintrees": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/bintrees/-/bintrees-1.0.2.tgz",
+      "integrity": "sha512-VOMgTMwjAaUG580SXn3LacVgjurrbMme7ZZNYGSSV7mmtY6QQRh0Eg3pwIcntQ77DErK1L0NxkbetjcoXzVwKw==",
+      "license": "MIT"
+    },
     "node_modules/bl": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz",
@@ -20891,6 +20897,20 @@
         "node": ">=0.4.0"
       }
     },
+    "node_modules/prom-client": {
+      "version": "15.1.3",
+      "resolved": "https://registry.npmjs.org/prom-client/-/prom-client-15.1.3.tgz",
+      "integrity": "sha512-6ZiOBfCywsD4k1BN9IX0uZhF+tJkV8q8llP64G5Hajs4JOeVLPCwpPVcpXy3BwYiUGgyJzsJJQeOIv7+hDSq8g==",
+      "deprecated": "prom-client has been replaced by @prometheus-io/client",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/api": "^1.4.0",
+        "tdigest": "^0.1.1"
+      },
+      "engines": {
+        "node": "^16 || ^18 || >=20"
+      }
+    },
     "node_modules/prop-types": {
       "version": "15.8.1",
       "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
@@ -22997,6 +23017,15 @@
         "node": ">=8.0.0"
       }
     },
+    "node_modules/tdigest": {
+      "version": "0.1.3",
+      "resolved": "https://registry.npmjs.org/tdigest/-/tdigest-0.1.3.tgz",
+      "integrity": "sha512-zbRt+lT+/H4fRItHshczHErVCQnitJk8MfMT24MqFJf3YL7SJJPqGIGeuOdvxXxM/AHFzKBl7WoyaYwqO9s3Kw==",
+      "license": "MIT",
+      "dependencies": {
+        "bintrees": "1.0.2"
+      }
+    },
     "node_modules/tedious": {
       "version": "20.0.0",
       "resolved": "https://registry.npmjs.org/tedious/-/tedious-20.0.0.tgz",
@@ -25010,6 +25039,7 @@
         "pg": "^8.23.1",
         "pino": "^10.3.1",
         "pino-http": "^11.0.0",
+        "prom-client": "^15.1.3",
         "reflect-metadata": "^0.2.2",
         "rxjs": "7.8.1",
         "soap": "^1.14.0",
diff --git a/packages/backend/package.json b/packages/backend/package.json
index 5b70cf2aa..52d8c76d1 100644
--- a/packages/backend/package.json
+++ b/packages/backend/package.json
@@ -75,6 +75,7 @@
     "pg": "^8.23.1",
     "pino": "^10.3.1",
     "pino-http": "^11.0.0",
+    "prom-client": "^15.1.3",
     "reflect-metadata": "^0.2.2",
     "rxjs": "7.8.1",
     "soap": "^1.14.0",
diff --git a/packages/backend/src/common/metrics.spec.ts b/packages/backend/src/common/metrics.spec.ts
new file mode 100644
index 000000000..8d4e7f01e
--- /dev/null
+++ b/packages/backend/src/common/metrics.spec.ts
@@ -0,0 +1,254 @@
+import { register as globalRegistry } from 'prom-client';
+import { recordToolCall, startMetricsServer, stopMetricsServer } from './metrics';
+
+const PORT = 19464;
+const BASE = `http://127.0.0.1:${PORT}/metrics`;
+const DEFAULT_TOKEN = 'a-very-long-test-token-value';
+const AUTH = { Authorization: `Bearer ${DEFAULT_TOKEN}` };
+
+/** server.listen() resolves asynchronously; retry past the brief window before it's bound. */
+async function fetchReady(url: string, init?: RequestInit, attempts = 20): Promise<Response> {
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fetch(url, init);
+    } catch (err) {
+      if (i === attempts - 1) throw err;
+      await new Promise((r) => setTimeout(r, 10));
+    }
+  }
+  throw new Error('unreachable');
+}
+
+const ENV_KEYS = [
+  'METRICS_ENABLED',
+  'METRICS_PORT',
+  'METRICS_HOST',
+  'METRICS_TOKEN',
+  'METRICS_TOOL_LABELS',
+  'DEPLOYMENT_MODE',
+] as const;
+
+describe('metrics', () => {
+  let savedEnv: Record<string, string | undefined>;
+
+  beforeEach(() => {
+    savedEnv = {};
+    for (const key of ENV_KEYS) savedEnv[key] = process.env[key];
+    for (const key of ENV_KEYS) delete process.env[key];
+    process.env.METRICS_PORT = String(PORT);
+    // METRICS_TOKEN is required whenever METRICS_ENABLED=true; most tests
+    // below are about something else, so give them a working token by
+    // default and have the token-specific tests override/delete it.
+    process.env.METRICS_TOKEN = DEFAULT_TOKEN;
+  });
+
+  afterEach(async () => {
+    await stopMetricsServer();
+    for (const key of ENV_KEYS) {
+      if (savedEnv[key] === undefined) delete process.env[key];
+      else process.env[key] = savedEnv[key];
+    }
+  });
+
+  it('does not start a listener or collect default metrics when METRICS_ENABLED is unset', async () => {
+    const server = startMetricsServer();
+    expect(server).toBeNull();
+
+    // recordToolCall before/without a running server is a no-op, not a throw.
+    expect(() =>
+      recordToolCall({ connectorType: 'rest', status: 'success', durationMs: 12 }),
+    ).not.toThrow();
+
+    await expect(fetch(BASE)).rejects.toThrow();
+
+    // Default metrics are only ever registered on our own Registry, never
+    // the global one prom-client exports — so the global stays empty even
+    // after other tests in this file enable metrics.
+    const globalText = await globalRegistry.metrics();
+    expect(globalText.trim()).toBe('');
+  });
+
+  it('refuses to start on self-hosted without METRICS_TOKEN, and logs an error', async () => {
+    process.env.METRICS_ENABLED = 'true';
+    delete process.env.METRICS_TOKEN;
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+    const server = startMetricsServer();
+    expect(server).toBeNull();
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+    expect(errorSpy.mock.calls[0][0]).toContain('METRICS_TOKEN');
+    await expect(fetch(BASE)).rejects.toThrow();
+
+    errorSpy.mockRestore();
+  });
+
+  it('refuses to start on Cloud without METRICS_TOKEN', async () => {
+    process.env.METRICS_ENABLED = 'true';
+    process.env.DEPLOYMENT_MODE = 'cloud';
+    delete process.env.METRICS_TOKEN;
+
+    const server = startMetricsServer();
+    expect(server).toBeNull();
+    await expect(fetch(BASE)).rejects.toThrow();
+  });
+
+  it('serves Prometheus text on GET /metrics, and the counters/histogram move after a tool call', async () => {
+    process.env.METRICS_ENABLED = 'true';
+    const server = startMetricsServer();
+    expect(server).not.toBeNull();
+
+    const before = await (await fetchReady(BASE, { headers: AUTH })).text();
+    expect(before).toContain('# HELP anythingmcp_tool_calls_total');
+    expect(before).not.toMatch(/anythingmcp_tool_calls_total\{[^}]*}\s+1/);
+
+    recordToolCall({ connectorType: 'rest', status: 'success', durationMs: 250, upstreamStatus: 200 });
+
+    const res = await fetch(BASE, { headers: AUTH });
+    expect(res.status).toBe(200);
+    const after = await res.text();
+    expect(after).toMatch(/anythingmcp_tool_calls_total\{connector_type="rest",status="success"}\s+1/);
+    // durationMs: 250 -> 0.25s; the histogram's _sum for this label set must
+    // actually reflect the observed value, not just mention the metric name.
+    expect(after).toMatch(/anythingmcp_tool_call_duration_seconds_sum\{connector_type="rest",status="success"}\s+0\.25/);
+    expect(after).toMatch(/anythingmcp_tool_call_duration_seconds_count\{connector_type="rest",status="success"}\s+1/);
+    // A 200 upstream status is not an error: the counter is declared (HELP
+    // line present) but never incremented, so no series exists for it at all.
+    expect(after).toContain('# HELP anythingmcp_tool_call_upstream_errors_total');
+    expect(after).not.toMatch(/anythingmcp_tool_call_upstream_errors_total\{[^}]*}\s+\d/);
+  });
+
+  it('returns 404 on any path other than GET /metrics', async () => {
+    process.env.METRICS_ENABLED = 'true';
+    startMetricsServer();
+
+    // 404 is decided before the auth check, so these need no token either way.
+    expect((await fetchReady(`http://127.0.0.1:${PORT}/other`)).status).toBe(404);
+    expect((await fetch(BASE, { method: 'POST' })).status).toBe(404);
+  });
+
+  it('returns 401 on a missing or wrong bearer token', async () => {
+    process.env.METRICS_ENABLED = 'true';
+    startMetricsServer();
+
+    expect((await fetchReady(BASE)).status).toBe(401);
+    expect((await fetch(BASE, { headers: { Authorization: 'Bearer wrong-token' } })).status).toBe(401);
+
+    const ok = await fetch(BASE, { headers: AUTH });
+    expect(ok.status).toBe(200);
+  });
+
+  it('logs and leaves metrics off, without crashing, when the port is already taken', async () => {
+    process.env.METRICS_ENABLED = 'true';
+    const first = startMetricsServer();
+    expect(first).not.toBeNull();
+    await fetchReady(BASE, { headers: AUTH }); // wait for the first listener to actually be bound
+
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    const second = startMetricsServer();
+    // The http.Server instance is still returned synchronously; 'error' fires
+    // asynchronously once the EADDRINUSE bind attempt actually fails.
+    expect(second).not.toBeNull();
+    await new Promise((resolve) => setImmediate(resolve));
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+    expect(errorSpy.mock.calls[0][0]).toContain('[metrics]');
+
+    errorSpy.mockRestore();
+    // Only close the first (still-bound) server; stopMetricsServer() in
+    // afterEach now points at the second, failed attempt (null internally).
+    await new Promise((resolve) => first!.close(() => resolve(undefined)));
+  });
+
+  it('ignores METRICS_TOOL_LABELS on Cloud and warns once, never adding connector_id/tool', async () => {
+    process.env.METRICS_ENABLED = 'true';
+    process.env.DEPLOYMENT_MODE = 'cloud';
+    process.env.METRICS_TOOL_LABELS = 'true';
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+    startMetricsServer();
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(warnSpy.mock.calls[0][0]).toContain('METRICS_TOOL_LABELS');
+
+    recordToolCall({
+      connectorType: 'rest',
+      status: 'success',
+      durationMs: 5,
+      connectorId: 'conn_abc123',
+      tool: 'my_tool',
+    });
+
+    const text = await (await fetchReady(BASE, { headers: AUTH })).text();
+    expect(text).toMatch(/anythingmcp_tool_calls_total\{connector_type="rest",status="success"}\s+1/);
+    expect(text).not.toContain('connector_id');
+    expect(text).not.toContain('conn_abc123');
+    expect(text).not.toContain('my_tool');
+
+    warnSpy.mockRestore();
+  });
+
+  it('never leaks connector_id/tool on self-hosted when METRICS_TOOL_LABELS is unset, even if the caller passes them', async () => {
+    process.env.METRICS_ENABLED = 'true';
+    startMetricsServer();
+
+    recordToolCall({
+      connectorType: 'rest',
+      status: 'success',
+      durationMs: 5,
+      connectorId: 'conn_should_not_leak',
+      tool: 'tool_should_not_leak',
+    });
+
+    const text = await (await fetchReady(BASE, { headers: AUTH })).text();
+    expect(text).not.toContain('connector_id');
+    expect(text).not.toContain('conn_should_not_leak');
+    expect(text).not.toContain('tool_should_not_leak');
+  });
+
+  it('adds connector_id/tool labels on self-hosted when METRICS_TOOL_LABELS=true', async () => {
+    process.env.METRICS_ENABLED = 'true';
+    process.env.METRICS_TOOL_LABELS = 'true';
+    startMetricsServer();
+
+    recordToolCall({
+      connectorType: 'rest',
+      status: 'error',
+      durationMs: 5,
+      connectorId: 'conn_abc123',
+      tool: 'my_tool',
+    });
+
+    const text = await (await fetchReady(BASE, { headers: AUTH })).text();
+    expect(text).toContain('connector_id="conn_abc123"');
+    expect(text).toContain('tool="my_tool"');
+  });
+
+  it('counts a 4xx or 5xx upstream status, but never a success', async () => {
+    process.env.METRICS_ENABLED = 'true';
+    startMetricsServer();
+
+    recordToolCall({ connectorType: 'rest', status: 'error', durationMs: 1, upstreamStatus: 404 });
+    recordToolCall({ connectorType: 'rest', status: 'error', durationMs: 1, upstreamStatus: 503 });
+    recordToolCall({ connectorType: 'rest', status: 'error', durationMs: 1 }); // no upstream status at all
+    recordToolCall({ connectorType: 'rest', status: 'success', durationMs: 1, upstreamStatus: 200 });
+
+    const text = await (await fetchReady(BASE, { headers: AUTH })).text();
+    expect(text).toMatch(/upstream_status_class="4xx"}\s+1/);
+    expect(text).toMatch(/upstream_status_class="5xx"}\s+1/);
+    expect(text).not.toContain('upstream_status_class="none"');
+    // Exactly the 4xx and 5xx calls counted — not the other two.
+    const matches = text.match(/anythingmcp_tool_call_upstream_errors_total\{[^}]*}\s+\d+/g) ?? [];
+    expect(matches).toHaveLength(2);
+  });
+
+  it('mirrors processGauges at scrape time', async () => {
+    process.env.METRICS_ENABLED = 'true';
+    startMetricsServer();
+
+    const { processGauges } = await import('./process-vitals');
+    processGauges.inc('toolCallsInFlight', 3);
+
+    const text = await (await fetchReady(BASE, { headers: AUTH })).text();
+    expect(text).toMatch(/anythingmcp_tool_calls_in_flight\s+3/);
+
+    processGauges.reset();
+  });
+});
diff --git a/packages/backend/src/common/metrics.ts b/packages/backend/src/common/metrics.ts
new file mode 100644
index 000000000..ef18acb28
--- /dev/null
+++ b/packages/backend/src/common/metrics.ts
@@ -0,0 +1,223 @@
+/**
+ * Prometheus metrics — opt-in.
+ *
+ * Off unless METRICS_ENABLED=true; otherwise no-op so the default install
+ * exposes nothing. Modeled on tracing.ts's env-gated, no-DI module pattern:
+ * a plain facade so a later switch to OTel metrics touches one file.
+ *
+ * A second, separate node:http listener — never the main Nest app or port
+ * 4000 — because /metrics must never be reachable through the public port
+ * that /health* is proxied on (deploy/cloud/Caddyfile, docs/deployment.md).
+ *
+ * METRICS_TOKEN is required whenever METRICS_ENABLED=true, on Cloud and
+ * self-hosted alike (mirrors SENTRY_VERIFY_TOKEN): the listener's default
+ * bind host is 0.0.0.0, so an unauthenticated self-hosted instance would
+ * serve /metrics to anyone who can reach the host.
+ *
+ * On Cloud (DEPLOYMENT_MODE=cloud), per-tool/per-connector labels are always
+ * dropped, even if METRICS_TOOL_LABELS=true — no series may carry a
+ * connector id or tool name across thousands of tenant workspaces.
+ *
+ * Uses its own Registry rather than prom-client's global default: the
+ * "disabled means nothing collected" guarantee would otherwise depend on
+ * collectDefaultMetrics() never having been called anywhere else in the
+ * process, including other test files sharing the global registry.
+ */
+import * as http from 'node:http';
+import {
+  Registry,
+  Counter,
+  Histogram,
+  Gauge,
+  collectDefaultMetrics,
+} from 'prom-client';
+import { sameSecret } from './secrets.util';
+import { processGauges } from './process-vitals';
+
+// Plain console wrappers, called through at each use (not bound once at
+// import time), so test spies on console.* take effect.
+const logger = {
+  log: (msg: string) => console.log(msg),
+  warn: (msg: string) => console.warn(msg),
+  error: (msg: string) => console.error(msg),
+};
+
+let server: http.Server | null = null;
+let registry: Registry | null = null;
+let toolCallsTotal: Counter<'connector_type' | 'status' | 'connector_id' | 'tool'> | null = null;
+let toolCallDuration: Histogram<'connector_type' | 'status' | 'connector_id' | 'tool'> | null = null;
+let upstreamErrorsTotal: Counter<'connector_type' | 'upstream_status_class' | 'connector_id' | 'tool'> | null = null;
+let toolLabelsEnabled = false;
+let toolLabelsWarned = false;
+
+function isCloud(): boolean {
+  return (process.env.DEPLOYMENT_MODE || 'self-hosted') === 'cloud';
+}
+
+export interface RecordToolCallInput {
+  connectorType: string;
+  status: 'success' | 'error';
+  durationMs: number;
+  upstreamStatus?: number;
+  connectorId?: string;
+  tool?: string;
+}
+
+function upstreamStatusClass(upstreamStatus?: number): '4xx' | '5xx' | null {
+  if (upstreamStatus == null) return null;
+  if (upstreamStatus >= 500) return '5xx';
+  if (upstreamStatus >= 400) return '4xx';
+  return null;
+}
+
+/** No-op until startMetricsServer() has actually created the registry. */
+export function recordToolCall(input: RecordToolCallInput): void {
+  if (!toolCallsTotal || !toolCallDuration || !upstreamErrorsTotal) return;
+
+  const extra =
+    toolLabelsEnabled && !isCloud()
+      ? { connector_id: input.connectorId ?? '', tool: input.tool ?? '' }
+      : {};
+
+  toolCallsTotal.inc({ connector_type: input.connectorType, status: input.status, ...extra });
+  toolCallDuration.observe(
+    { connector_type: input.connectorType, status: input.status, ...extra },
+    input.durationMs / 1000,
+  );
+
+  // Only an actual upstream error moves this counter — a successful call
+  // (or one with no upstream status at all) never increments it.
+  const statusClass = upstreamStatusClass(input.upstreamStatus);
+  if (statusClass) {
+    upstreamErrorsTotal.inc({
+      connector_type: input.connectorType,
+      upstream_status_class: statusClass,
+      ...extra,
+    });
+  }
+}
+
+function sendMetrics(reg: Registry, res: http.ServerResponse): void {
+  reg
+    .metrics()
+    .then((body) => {
+      res.writeHead(200, { 'Content-Type': reg.contentType });
+      res.end(body);
+    })
+    .catch((err) => {
+      logger.error(`[metrics] failed to render: ${err}`);
+      res.writeHead(500);
+      res.end();
+    });
+}
+
+/**
+ * Starts the /metrics listener if METRICS_ENABLED=true, else returns null.
+ * Idempotent-ish for tests: call stopMetricsServer() between starts.
+ */
+export function startMetricsServer(): http.Server | null {
+  if (process.env.METRICS_ENABLED !== 'true') return null;
+
+  const token = process.env.METRICS_TOKEN;
+  if (!token) {
+    logger.error('[metrics] METRICS_TOKEN must be set when METRICS_ENABLED=true; metrics stay off.');
+    return null;
+  }
+
+  toolLabelsEnabled = process.env.METRICS_TOOL_LABELS === 'true';
+  if (toolLabelsEnabled && isCloud() && !toolLabelsWarned) {
+    logger.warn('[metrics] METRICS_TOOL_LABELS is ignored on Cloud: no connector_id/tool label is ever added.');
+    toolLabelsWarned = true;
+  }
+  // Decided once per server lifetime: identity labels are never added on
+  // Cloud, matching the same check recordToolCall() makes at call time.
+  const withIdentityLabels = toolLabelsEnabled && !isCloud();
+
+  registry = new Registry();
+  collectDefaultMetrics({ register: registry });
+
+  toolCallsTotal = new Counter({
+    name: 'anythingmcp_tool_calls_total',
+    help: 'Total tool calls, by connector type and outcome.',
+    labelNames: withIdentityLabels ? ['connector_type', 'status', 'connector_id', 'tool'] : ['connector_type', 'status'],
+    registers: [registry],
+  });
+  toolCallDuration = new Histogram({
+    name: 'anythingmcp_tool_call_duration_seconds',
+    help: 'Tool call duration in seconds, by connector type and outcome.',
+    // Tool calls can take 20s or more; cover 50ms to 60s.
+    buckets: [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 20, 30, 60],
+    labelNames: withIdentityLabels ? ['connector_type', 'status', 'connector_id', 'tool'] : ['connector_type', 'status'],
+    registers: [registry],
+  });
+  upstreamErrorsTotal = new Counter({
+    name: 'anythingmcp_tool_call_upstream_errors_total',
+    help: 'Tool calls whose upstream response was a 4xx or 5xx, by status class. Never incremented for a successful call.',
+    labelNames: withIdentityLabels ? ['connector_type', 'upstream_status_class', 'connector_id', 'tool'] : ['connector_type', 'upstream_status_class'],
+    registers: [registry],
+  });
+
+  // Mirror the existing in-process gauges at scrape time — not on an
+  // interval — so a value read between scrapes is never stale.
+  for (const name of ['toolCallsInFlight', 'mcpRequestsInFlight', 'registeredTools']) {
+    new Gauge({
+      name: `anythingmcp_${name.replace(/([A-Z])/g, '_$1').toLowerCase()}`,
+      help: `Mirror of processGauges['${name}'].`,
+      registers: [registry],
+      collect() {
+        this.set(processGauges.snapshot()[name] ?? 0);
+      },
+    });
+  }
+
+  const port = Number(process.env.METRICS_PORT) || 9464;
+  const host = process.env.METRICS_HOST || '0.0.0.0';
+  const reg = registry;
+
+  server = http.createServer((req, res) => {
+    if (req.method !== 'GET' || req.url !== '/metrics') {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+    const header = req.headers.authorization || '';
+    const presented = header.startsWith('Bearer ') ? header.slice(7) : '';
+    if (!presented || !sameSecret(presented, token)) {
+      res.writeHead(401);
+      res.end();
+      return;
+    }
+    sendMetrics(reg, res);
+  });
+
+  // listen() emits 'error' instead of throwing (e.g. EADDRINUSE) — without a
+  // handler that's an uncaught exception that takes the whole backend down,
+  // not just the metrics listener.
+  server.on('error', (err) => {
+    logger.error(`[metrics] listener failed, metrics stay off: ${err}`);
+    server = null;
+    registry = null;
+    toolCallsTotal = null;
+    toolCallDuration = null;
+    upstreamErrorsTotal = null;
+  });
+
+  server.listen(port, host, () => {
+    logger.log(`[metrics] listening on http://${host}:${port}/metrics`);
+  });
+
+  return server;
+}
+
+export function stopMetricsServer(): Promise<void> {
+  const current = server;
+  server = null;
+  registry = null;
+  toolCallsTotal = null;
+  toolCallDuration = null;
+  upstreamErrorsTotal = null;
+  toolLabelsEnabled = false;
+  toolLabelsWarned = false;
+  if (!current) return Promise.resolve();
+  return new Promise((resolve) => current.close(() => resolve()));
+}
diff --git a/packages/backend/src/common/secrets.util.ts b/packages/backend/src/common/secrets.util.ts
index 465f9c8fa..bcfc27954 100644
--- a/packages/backend/src/common/secrets.util.ts
+++ b/packages/backend/src/common/secrets.util.ts
@@ -1,7 +1,15 @@
 import { Logger } from '@nestjs/common';
+import { timingSafeEqual } from 'node:crypto';
 
 const logger = new Logger('Secrets');
 
+/** Constant-time string equality, safe for comparing a presented token against a stored secret. */
+export function sameSecret(a: string, b: string): boolean {
+  const x = Buffer.from(a);
+  const y = Buffer.from(b);
+  return x.length === y.length && timingSafeEqual(x, y);
+}
+
 const MIN_SECRET_LENGTH = 32;
 
 /**
diff --git a/packages/backend/src/health/sentry-verify.controller.ts b/packages/backend/src/health/sentry-verify.controller.ts
index 113da3db2..902b5331b 100644
--- a/packages/backend/src/health/sentry-verify.controller.ts
+++ b/packages/backend/src/health/sentry-verify.controller.ts
@@ -1,6 +1,6 @@
 import { Controller, Get, Headers, NotFoundException } from '@nestjs/common';
 import { ApiExcludeController } from '@nestjs/swagger';
-import { timingSafeEqual } from 'node:crypto';
+import { sameSecret } from '../common/secrets.util';
 
 /**
  * Throws a deliberate error so an operator can confirm, end to end, that
@@ -23,9 +23,3 @@ export class SentryVerifyController {
     throw new Error('Sentry verification (backend)');
   }
 }
-
-function sameSecret(a: string, b: string): boolean {
-  const x = Buffer.from(a);
-  const y = Buffer.from(b);
-  return x.length === y.length && timingSafeEqual(x, y);
-}
diff --git a/packages/backend/src/main.ts b/packages/backend/src/main.ts
index 2b4632ac2..2b1d2b2dc 100644
--- a/packages/backend/src/main.ts
+++ b/packages/backend/src/main.ts
@@ -29,6 +29,7 @@ import { AppModule } from './app.module';
 import { mcpStrategy } from './mcp-server/mcp-strategy';
 import { McpAuthExceptionFilter } from './auth/mcp-auth-exception.filter';
 import { validateRequiredSecretsAtStartup } from './common/secrets.util';
+import { startMetricsServer, stopMetricsServer } from './common/metrics';
 
 async function bootstrap() {
   // Fail fast if required secrets are missing or use known placeholder values.
@@ -171,6 +172,10 @@ async function bootstrap() {
   server.keepAliveTimeout = 65_000;
   server.headersTimeout = 66_000;
 
+  // Second, separate listener — never the main app or port 4000, since
+  // /health* is proxied publicly on both Cloud and self-hosted.
+  startMetricsServer();
+
   // A SIGTERM must end in an exit, every time, within a bounded time.
   //
   // It did not. `app.close()` calls `server.close()`, which resolves only
@@ -206,6 +211,7 @@ async function bootstrap() {
       }, cutConnectionsAfterMs);
       cutter.unref();
       try {
+        await stopMetricsServer();
         await app.close();
         logger.log('Shutdown complete.');
         process.exit(0);
diff --git a/packages/backend/src/mcp-server/dynamic-mcp-tools.ts b/packages/backend/src/mcp-server/dynamic-mcp-tools.ts
index 95cb2e958..2cba26e8d 100644
--- a/packages/backend/src/mcp-server/dynamic-mcp-tools.ts
+++ b/packages/backend/src/mcp-server/dynamic-mcp-tools.ts
@@ -33,6 +33,7 @@ import type { ResponseMapping } from '../connectors/engines/engine-types';
 import type { RegisteredTool } from './tool-registry';
 import { deriveErrorHint, hostFromAxiosConfig, hostFromUrl } from './error-hints';
 import { processGauges } from '../common/process-vitals';
+import { recordToolCall } from '../common/metrics';
 import { applySchemaDefaults } from '../common/schema-defaults.util';
 import { renderStaticResponse } from '../connectors/static-response.util';
 import { ODataEngine, isODataBuiltinMethod } from '../connectors/engines/odata.engine';
@@ -152,6 +153,14 @@ export class DynamicMcpTools {
     upstreamStatus?: number,
   ): void {
     const resultBytes = renderedText ? Buffer.byteLength(renderedText) : 0;
+    recordToolCall({
+      connectorType: tool.connectorType,
+      status: status === 'SUCCESS' ? 'success' : 'error',
+      durationMs,
+      upstreamStatus,
+      connectorId: tool.connectorId,
+      tool: tool.name,
+    });
     const line = {
       msg: 'tool_call',
       toolName: tool.name,