Memgraph Helm Charts

Welcome to the Memgraph Helm Charts repository. This repository provides Helm charts for deploying Memgraph, an open-source in-memory graph database.

Available charts

• Memgraph standalone
• Memgraph Lab
• Memgraph high availability

Prerequisites

Helm version 3 or above installed.

Add the Helm repository

Add the Memgraph Helm chart repository to your local Helm setup by running the following command:

helm repo add memgraph https://memgraph.github.io/helm-charts

Update the repository

Make sure to update the repository to fetch the latest Helm charts available:

helm repo update

Memgraph standalone

Deploys standalone Memgraph. For detailed information and usage instructions, please refer to the chart's individual README file.

To install the Memgraph standalone chart, run the following command:

helm install my-release memgraph/memgraph

Replace my-release with a name of your choice for the release.

Once Memgraph is installed, you can access it using the provided services and endpoints. Refer to the Memgraph documentation for details on how to connect to and interact with Memgraph.

To upgrade or uninstall a deployed Memgraph release, you can use the helm upgrade or helm uninstall commands, respectively. Refer to the Helm documentation for more details on these commands.

Memgraph lab

Deploys Memgraph Lab. For detailed information and usage instructions, please refer to the chart's individual README file.

To install Memgraph Lab, run the following command:

helm install my-release memgraph/memgraph-lab

Replace my-release with a name of your choice for the release.

Refer to the Data visualization in Memgraph Lab for details on how to connect to and interact with Memgraph.

To upgrade or uninstall a deployed Memgraph release, you can use the helm upgrade or helm uninstall commands, respectively. Refer to the Helm documentation for more details on these commands.

Memgraph high availability

Deploys high available Memgraph cluster, that includes two data instances and three coordinators.

For detailed information and usage instructions, please refer to the chart's individual README file.

To install the chart, first create a Kubernetes secret holding your Memgraph Enterprise license and organization name (the HA chart reads these via secretKeyRef), then install the chart:

kubectl create secret generic memgraph-secrets \
  --from-literal=MEMGRAPH_ENTERPRISE_LICENSE=<your-license> \
  --from-literal=MEMGRAPH_ORGANIZATION_NAME=<your-organization-name>

helm install my-release memgraph/memgraph-high-availability

Replace my-release with a name of your choice for the release. The secret name and keys are configurable via secrets.name, secrets.licenseKey, and secrets.organizationKey.

There are a few additional steps to make the cluster fully operational. Please take a look under the Setting up the cluster docs section.

Once Memgraph cluster is up and running, you can access it using the provided services and endpoints. Refer to the Memgraph documentation for details on how to connect to and interact with Memgraph.

To upgrade or uninstall a deployed Memgraph release, you can use the helm upgrade or helm uninstall commands, respectively. Refer to the Helm documentation for more details on these commands.

Remote Metrics and Logging

Both Memgraph charts support optional remote observability:

• Remote metrics via vmagentRemote using Prometheus remote_write.
• Remote logs via vectorRemote using Loki-compatible push API.

This works with VictoriaMetrics/VictoriaLogs, and with other backends that expose compatible Prometheus remote-write and Loki endpoints.

Prerequisites

• Provide a metrics source for vmagentRemote, either:
  • the chart-level Prometheus exporter (prometheus.enabled=true) — the default, or
  • direct scraping of Memgraph's OpenMetrics endpoint (top-level scrapeMemgraphDirectly=true), which needs no exporter (prometheus.enabled=false). See Scrape Memgraph directly.
• Use a secret containing credentials for your remote endpoints (required for vmagentRemote; optional for vectorRemote).
• For standalone chart, enable Memgraph monitoring ports:
  • service.enableHttpMonitoring=true
  • service.enableWebsocketMonitoring=true
• If vectorRemote.enabled=true, add Memgraph monitoring flags:
  • standalone chart: add --monitoring-port=<service.websocketPortMonitoring> and --monitoring-address=0.0.0.0 to memgraphConfig
  • HA chart: add --monitoring-port=<vectorRemote.websocketPort> and --monitoring-address=0.0.0.0 to each instance's args
• If vmagentRemote.enabled=true and you only need remote_write, set prometheus.serviceMonitor.enabled=false to avoid duplicate scraping of mg-exporter by both vmagent and kube-prometheus.

Scrape Memgraph directly (without mg-exporter)

By default vmagentRemote scrapes the mg-exporter, which requires prometheus.enabled=true. To scrape Memgraph's OpenMetrics endpoint directly instead — with no exporter deployed — set the top-level scrapeMemgraphDirectly=true and leave prometheus.enabled=false:

# Top-level master switch: Memgraph serves OpenMetrics and all scrapers hit it directly.
scrapeMemgraphDirectly: true

prometheus:
  enabled: false  # mg-exporter not needed

vmagentRemote:
  enabled: true
  namespace: monitoring
  remoteWrite:
    url: "https://<prom-remote-write>/api/v1/write"
    basicAuth:
      secretName: monitoring-basic-auth
      usernameKey: username
      passwordKey: password
  externalLabels:
    cluster_id: "memgraph-ha"
    service_name: "Memgraph HA"
    cluster_env: "dev"

When scrapeMemgraphDirectly=true, the chart runs each instance with --metrics-format=OpenMetrics and exposes the metrics port automatically (for the standalone chart you do not need to set service.enableHttpMonitoring). All other vmagentRemote / vectorRemote settings are the same as the examples below. The metrics endpoint is served over plain HTTP.

Whenever the chart provisions a scraper it pins --metrics-format to match it: OpenMetrics with scrapeMemgraphDirectly=true, JSON with prometheus.enabled=true, because that is the format the mg-exporter reads. Memgraph 3.13 changes the server-side default from JSON to OpenMetrics, so a chart that leaves the flag unset hands the exporter a payload it cannot parse. With neither switch set the chart pins nothing and Memgraph uses its own default. If you set both, scrapeMemgraphDirectly wins and the instances serve OpenMetrics. Setting --metrics-format yourself takes precedence in the standalone chart; the HA chart rejects it, so configure the switches instead.

In-cluster scraping with kube-prometheus-stack

For an in-cluster Prometheus (e.g. kube-prometheus-stack), set prometheus.serviceMonitor.enabled=true to provision a ServiceMonitor. By default it scrapes the mg-exporter; set the top-level scrapeMemgraphDirectly=true to scrape Memgraph's OpenMetrics endpoint directly instead (no exporter; requires Memgraph >= 3.11). The same scrapeMemgraphDirectly switch governs both the in-cluster ServiceMonitor and the remote vmagentRemote.

Set prometheus.grafanaDashboard.enabled=true to ship the bundled "Memgraph OpenMetrics" dashboard as a ConfigMap (labelled grafana_dashboard) for the Grafana sidecar to auto-load. It uses a datasource template variable, so it binds to Grafana's default Prometheus. The ConfigMap must live in a namespace the sidecar watches — set prometheus.grafanaDashboard.namespace to Grafana's namespace (or run the sidecar with searchNamespace: ALL).

Grafana dashboards

Both charts bundle two dashboards under charts/<chart>/dashboards/, each shipped as a ConfigMap (labelled grafana_dashboard) for a Grafana sidecar to auto-load, and each behind its own flag:

prometheus:
  grafanaDashboard:
    enabled: true
    namespace: monitoring   # must be a namespace the Grafana sidecar watches

vectorRemote:
  grafanaDashboard:
    enabled: true
    namespace: monitoring

Each ConfigMap must live in a namespace the sidecar watches — set namespace to Grafana's namespace (or run the sidecar with searchNamespace: ALL). Both default to prometheus.namespace, else the release namespace.

If you do not run a Grafana sidecar, import the JSON files above by hand instead. Both use datasource template variables rather than hardcoded datasource UIDs. The OpenMetrics dashboard needs a Prometheus-compatible datasource ("Data source"); the logs dashboard needs a VictoriaLogs datasource ("Logs data source") plus a Prometheus-compatible one ("Metrics data source") that populates its filters.

Standalone chart example

prometheus:
  enabled: true
  namespace: monitoring
  serviceMonitor:
    enabled: false

service:
  enableHttpMonitoring: true
  enableWebsocketMonitoring: true

memgraphConfig:
  - "--data-directory=/var/lib/memgraph/mg_data"
  - "--also-log-to-stderr=true"
  - "--monitoring-port=7444"
  - "--monitoring-address=0.0.0.0"

vmagentRemote:
  enabled: true
  namespace: monitoring
  remoteWrite:
    url: "https://<prom-remote-write>/api/v1/write"
    basicAuth:
      secretName: monitoring-basic-auth
      usernameKey: username
      passwordKey: password
  externalLabels:
    cluster_id: "memgraph-standalone"
    service_name: "memgraph"
    cluster_env: "dev"

vectorRemote:
  enabled: true
  logsEndpoint: "https://<loki-endpoint>"
  # Optional: only set auth when endpoint requires basic auth.
  auth:
    secretName: monitoring-basic-auth
    usernameKey: username
    passwordKey: password
  extraLabels:
    cluster_id: "memgraph-standalone"
    service_name: "memgraph"
    cluster_env: "dev"
    role: "standalone"

High availability chart example

prometheus:
  enabled: true
  namespace: monitoring
  serviceMonitor:
    enabled: false

vmagentRemote:
  enabled: true
  namespace: monitoring
  remoteWrite:
    url: "https://<prom-remote-write>/api/v1/write"
    basicAuth:
      secretName: monitoring-basic-auth
      usernameKey: username
      passwordKey: password
  externalLabels:
    cluster_id: "memgraph-testing-cluster-53"
    service_name: "Memgraph HA"
    cluster_env: "self-hosted-large-01"

vectorRemote:
  enabled: true
  data: true
  coordinators: true
  websocketPort: 7444
  logsEndpoint: "https://<loki-endpoint>"
  # Optional: only set auth when endpoint requires basic auth.
  auth:
    secretName: monitoring-basic-auth
    usernameKey: username
    passwordKey: password
  extraLabels:
    cluster_id: "memgraph-testing-cluster-53"
    service_name: "Memgraph HA"
    cluster_env: "self-hosted-large-01"

data:
  - id: "0"
    args:
      - "--management-port=10000"
      - "--bolt-port=7687"
      - "--monitoring-port=7444"
      - "--monitoring-address=0.0.0.0"
  - id: "1"
    args:
      - "--management-port=10000"
      - "--bolt-port=7687"
      - "--monitoring-port=7444"
      - "--monitoring-address=0.0.0.0"

coordinators:
  - id: "1"
    args:
      - "--coordinator-id=1"
      - "--coordinator-port=12000"
      - "--management-port=10000"
      - "--bolt-port=7687"
      - "--monitoring-port=7444"
      - "--monitoring-address=0.0.0.0"
  - id: "2"
    args:
      - "--coordinator-id=2"
      - "--coordinator-port=12000"
      - "--management-port=10000"
      - "--bolt-port=7687"
      - "--monitoring-port=7444"
      - "--monitoring-address=0.0.0.0"
  - id: "3"
    args:
      - "--coordinator-id=3"
      - "--coordinator-port=12000"
      - "--management-port=10000"
      - "--bolt-port=7687"
      - "--monitoring-port=7444"
      - "--monitoring-address=0.0.0.0"

Optional auth secrets for remote endpoints

Create the same secret in all namespaces where the components run:

kubectl create secret generic monitoring-basic-auth -n monitoring \
  --from-literal=username='<username>' \
  --from-literal=password='<password>'

For HA and standalone vector sidecars, also create the same secret in the Memgraph release namespace (for example default or memgraph):

kubectl create secret generic monitoring-basic-auth -n <memgraph-namespace> \
  --from-literal=username='<username>' \
  --from-literal=password='<password>'

Export Kubernetes infrastructure metrics with vmagentRemote

vmagentRemote can additionally scrape Kubernetes infrastructure metrics (kube-state-metrics, node-exporter, kubelet) and remote-write them alongside the Memgraph metrics. See the Memgraph docs for setup details:

• Standalone: Remote metrics and logs — Kubernetes infrastructure metrics
• HA: Remote metrics and logs — Kubernetes infrastructure metrics

Ready-to-use example values live under examples/remote-monitoring/:

• Standalone: values-standalone-k8s-metrics.yaml
• HA: values-ha-k8s-metrics.yaml

Docker Compose

Creates HA Memgraph cluster with one command. The only thing you need to do is add your license details. Used bridged docker network for communication.

Contributing

Contributions are welcome! If you have any improvements, bug fixes, or new charts to add, please follow the contribution guidelines outlined in the CONTRIBUTING.md file. If you have questions and are unsure of how to contribute, please join our Discord server to get in touch with us.

Debugging Memgraph Pods

Find more details under Debugging Running Pods documentation section.

License

This repository is licensed under the Apache 2.0 License.