ilert MCP connector

Deploy the read-only connector that lets ilert-hosted MCP servers reach Kafka, MySQL, PostgreSQL, ClickHouse and Redis inside your own network.

The ilert MCP connector is a small service you deploy in your own network. It exposes a read-only REST API over the systems that normally have no public endpoint — Kafka, MySQL, PostgreSQL, ClickHouse and Redis — so the ilert-hosted MCP servers can reach them without ilert needing direct access to your broker or database.

One connector serves all of these systems. If you use more than one of them, enable them on the same deployment rather than running a connector per system.

The connector is open source: github.com/iLert/ilert-mcp-connector.

The connector must be reachable from the internet over a public HTTPS URL — that is its entire purpose. Put it behind a load balancer, ingress controller or reverse proxy, and protect it with the auth token described below.

Generate the auth token

The connector authenticates every request against the AUTH_TOKEN environment variable. This is the value you later paste as the Secret value when you connect the MCP server to an agent, so generate it first and keep it:

openssl rand -hex 32

If you start the connector without AUTH_TOKEN, it generates a random token and writes it to the startup log. Setting it explicitly is strongly recommended — otherwise the token changes on every restart.

Deploy the connector

Enable only the systems you need — each one is off until you set its *_ENABLED variable, and only the endpoints of enabled systems are registered. The variables for each system are listed in the configuration sections further down this page.

Option 1: Deploy using Docker

1

Pull the connector image:

docker pull ghcr.io/ilert/ilert-mcp-connector:latest

2

Run the container, enabling the systems you need and passing the token you generated:

docker run -d \
  --name ilert-mcp-connector \
  -p 8383:8383 \
  -e AUTH_TOKEN=your_generated_secret \
  -e MYSQL_ENABLED=true \
  -e MYSQL_HOST=mysql.internal \
  -e MYSQL_USER=ilert_mcp_connector \
  -e MYSQL_PASSWORD=your_password \
  -e REDIS_ENABLED=true \
  -e REDIS_HOST=redis.internal \
  -e REDIS_PASSWORD=your_password \
  ghcr.io/ilert/ilert-mcp-connector:latest

Drop the blocks you do not need and add KAFKA_*, POSTGRES_* or CLICKHOUSE_* variables the same way.

Option 2: Deploy using Kubernetes

1

Create a secret holding the auth token, plus one per system whose credentials the connector needs:

kubectl create secret generic ilert-mcp-secret \
  --from-literal=authToken=your_generated_secret

kubectl create secret generic mysql-secret \
  --from-literal=username=ilert_mcp_connector \
  --from-literal=password=your_password

2

Create the deployment manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ilert-mcp-connector
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ilert-mcp-connector
  template:
    metadata:
      labels:
        app: ilert-mcp-connector
    spec:
      containers:
      - name: ilert-mcp-connector
        image: ghcr.io/ilert/ilert-mcp-connector:latest
        ports:
        - containerPort: 8383
        env:
        - name: PORT
          value: "8383"
        - name: AUTH_TOKEN
          valueFrom:
            secretKeyRef:
              name: ilert-mcp-secret
              key: authToken
        - name: MYSQL_ENABLED
          value: "true"
        - name: MYSQL_HOST
          value: "mysql"
        - name: MYSQL_PORT
          value: "3306"
        - name: MYSQL_USER
          valueFrom:
            secretKeyRef:
              name: mysql-secret
              key: username
        - name: MYSQL_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-secret
              key: password
        livenessProbe:
          httpGet:
            path: /health
            port: 8383
          initialDelaySeconds: 10
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 8383
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: ilert-mcp-connector
spec:
  selector:
    app: ilert-mcp-connector
  ports:
  - port: 8383
    targetPort: 8383

3

Apply it:

kubectl apply -f deployment.yaml

Use /health for Kubernetes probes, not /ready. /ready requires the auth token and returns connection error details for every enabled system.

Server configuration

Variable	Default	Description
AUTH_TOKEN	auto-generated	Token required on every data request. Sent by ilert as Authorization: Bearer <token>.
PORT	8383	Port the connector listens on.
LOG_LEVEL	info	debug, info, warn, error, fatal or panic.
LOG_FORMAT	console	Set to json for structured logs.

Kafka configuration

Variable	Default	Description
KAFKA_ENABLED	false	Set to true to enable the Kafka endpoints.
KAFKA_BROKERS	localhost:9092	Comma-separated broker list.
KAFKA_CLIENT_ID	ilert-mcp-connector	Client ID the connector registers with.
KAFKA_AUTH_TYPE	NONE	NONE, PLAIN, SCRAM-SHA-256, SCRAM-SHA-512, SSL or SASL_SSL. If a username and password are set but this is not, it falls back to PLAIN.
KAFKA_USERNAME / KAFKA_PASSWORD	empty	SASL credentials, required for the PLAIN, SCRAM-* and SASL_SSL types.
KAFKA_SSL_CERT_LOCATION / KAFKA_SSL_KEY_LOCATION	empty	Paths to the client certificate and private key, required for SSL and SASL_SSL.
KAFKA_SSL_CA_LOCATION	empty	Path to the CA certificate. Optional but recommended.
KAFKA_SSL_KEY_PASSWORD	empty	Password for an encrypted private key.
KAFKA_SSL_INSECURE_SKIP_TLS	false	Skips TLS certificate verification. Not recommended in production.
KAFKA_LOG_LEVEL	6	Log level of the underlying Kafka client, 0 (emergency) to 7 (debug). Raise it to 7 when debugging broker connectivity.

MySQL configuration

Variable	Default	Description
MYSQL_ENABLED	false	Set to true to enable the MySQL endpoints.
MYSQL_HOST	localhost	MySQL host.
MYSQL_PORT	3306	MySQL port.
MYSQL_USER	root	The read-only user you created for the connector.
MYSQL_PASSWORD	empty	Password for that user.
MYSQL_DATABASE	empty	Default database for the connection. The agent addresses other databases by name.

PostgreSQL configuration

PostgreSQL isn't generally available yet — the connector already serves it, but there is no PostgreSQL card to attach to an agent. Select PostgreSQL in the agent wizard and click Request beta access, and we will reach out when it is ready. You can enable the variables below in the meantime.

Variable	Default	Description
POSTGRES_ENABLED	false	Set to true to enable the PostgreSQL endpoints.
POSTGRES_HOST	localhost	PostgreSQL host.
POSTGRES_PORT	5432	PostgreSQL port.
POSTGRES_USER	postgres	The read-only monitoring user you created for the connector.
POSTGRES_PASSWORD	empty	Password for that user.
POSTGRES_DATABASE	postgres	Database the connection is opened against. Other databases are reached on demand.
POSTGRES_SSLMODE	disable	disable, require, verify-ca or verify-full.

The connector reads databases, tables (as schema.table), table schemas with their statistics, and server metrics — current sessions, per-database statistics, configuration values, replication and replay lag, connection counts against max_connections, locks and blocked queries, checkpoint and buffer statistics, vacuum and dead-tuple pressure, plus long-running and idle-in-transaction sessions. There is no arbitrary-query endpoint.

Create the PostgreSQL user

The connector only reads system catalogs and statistics views. A plain user sees just its own sessions in pg_stat_activity, so grant the built-in monitoring role:

CREATE USER mcp_connector WITH PASSWORD 'your_password';
GRANT pg_monitor TO mcp_connector;
GRANT CONNECT ON DATABASE your_database TO mcp_connector;

pg_monitor (PostgreSQL 10 and later) covers pg_stat_activity, pg_stat_replication, pg_stat_database, pg_stat_bgwriter / pg_stat_checkpointer and pg_settings.

PostgreSQL cannot query across databases on one connection. When a request addresses a database other than POSTGRES_DATABASE, the connector opens a short-lived connection to it — so repeat the GRANT CONNECT for every database that should be reachable.

ClickHouse configuration

Variable	Default	Description
CLICKHOUSE_ENABLED	false	Set to true to enable the ClickHouse endpoints.
CLICKHOUSE_HOST	localhost	ClickHouse host.
CLICKHOUSE_PORT	9000	Native protocol port.
CLICKHOUSE_USER	default	ClickHouse user.
CLICKHOUSE_PASSWORD	empty	Password for that user.
CLICKHOUSE_DATABASE	default	Default database for the connection.

Redis configuration

Variable	Default	Description
REDIS_ENABLED	false	Set to true to enable the Redis endpoints.
REDIS_HOST	localhost	Redis host.
REDIS_PORT	6379	Redis port.
REDIS_PASSWORD	empty	Redis password. Leave unset if no password is configured.
REDIS_ENABLE_SENSITIVE_TOOLS	false	Allows reading the values stored in keys. While this is false, the connector answers that request with 403 and only key metadata is available.

There is no database-number setting — the agent selects the Redis database per request, so all databases on the instance are reachable.

Reading key values is gated twice. The agent can only read stored values when REDIS_ENABLE_SENSITIVE_TOOLS=true on the connector and the get_key_values tool is enabled on the agent's Tools tab — both are off by default, and the connector-side flag is the one you control in your own network.

Even when enabled, the endpoint stays narrow: at most 20 keys per call and each value truncated to 1 KB. Keys holding a non-string type, and binary values that are not valid text, are reported as such instead of being returned.

Verify the deployment

GET /health is public and only says the process is up:

curl https://ilert-mcp-connector.example.com/health

GET /ready needs the token and reports one check per enabled system — this is the call that tells you whether the connector can actually reach your broker or database:

curl -H "Authorization: Bearer your_generated_secret" \
  https://ilert-mcp-connector.example.com/ready

A healthy response looks like this:

{ "status": "ready", "checks": { "mysql": "ok", "postgres": "ok", "redis": "ok" } }

Anything other than ok is the driver's own error message — fix that before connecting the MCP server in ilert, because the agent hits the same code path.

Two more endpoints are public, next to /health:

• GET /version returns the connector's version and build commit — use it to check which image is actually running after an upgrade.
• GET /metrics exposes Prometheus metrics, including a counter per system operation and its errors, so you can alert on a connector that stops reaching your database.

/health, /version and /metrics need no token, so they are readable by anyone who can reach the URL. They expose no data from your systems, but if that is not acceptable, restrict them at your ingress or reverse proxy.

Used by

KafkaMySQLClickhouseRedis