# Causely documentation: quickstart-guides

> Full content of the "quickstart-guides" section of the Causely documentation.

This file contains all documentation content in a single document following the llmstxt.org standard.

## AWS Quickstart Guide

This quickstart guide will help you get Causely up and running on AWS. This setup deploys Causely in your Kubernetes cluster (including EKS) with eBPF instrumentation enabled, and connects it to your AWS account to monitor cloud resources.

### Get Your Installation Command

1. Log in to the [Causely portal](https://portal.causely.app).
2. Visit the [mediators page](https://portal.causely.app/agents).
3. Click the **"Add new"** button (or **"Add ➕"** button) on the mediators page.
4. In the instructions panel, you'll see the Helm installation command with your access token pre-filled.
5. Copy the complete Helm command. It will look similar to the example below.

:::info Example Command

The command you copy will include your specific access token and cluster name. Here's what it typically looks like:

```bash
export CAUSELY_TOKEN=<your_token>
export CAUSELY_CLUSTER_NAME=<your_cluster_name>
export CAUSELY_VERSION=<version>
helm upgrade --install causely \\
  --create-namespace oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}" \\
  --namespace=causely \\
  --set image.tag="${CAUSELY_VERSION}" \\
  --set global.cluster_name="\${CAUSELY_CLUSTER_NAME}" \\
  --set mediator.gateway.token="\${CAUSELY_TOKEN}"
```

:::

:::info Screenshot Placeholder

Screenshots of the mediators page, "Add new" button, and instructions panel will be added here.

:::

### Run the Installation Command

1. Open a terminal with `kubectl` configured to access your Kubernetes cluster.
2. Paste and run the Helm command you copied from the portal.
3. Wait for the installation to complete:

```bash
kubectl wait --for=condition=Ready pod -l app.kubernetes.io/part-of=causely -n causely --timeout=300s
```

:::info

By default, Causely will use [eBPF-based instrumentation](/telemetry-sources/ebpf) to automatically instrument your applications running in Kubernetes. This provides zero-effort observability without code changes.

:::

### Connect Your AWS Account

Now you need to configure Causely to monitor your AWS resources. Causely supports two authentication methods: IAM Role (recommended for EKS) or Access Keys.

##### Option 1: IAM Role (Recommended for EKS)

If you're running on Amazon EKS, we recommend using IAM roles for service accounts (IRSA) or EKS Pod Identity for secure authentication.

1. **Create an IAM role** with the necessary permissions. See the [AWS integration documentation](/telemetry-sources/aws/) for the required IAM policy and trust relationship.

2. **Annotate the mediator service account** to use the IAM role:

```bash
kubectl annotate serviceaccount causely-mediator \
  -n causely \
  eks.amazonaws.com/role-arn=arn:aws:iam::ACCOUNT_ID:role/CAUSELY_ROLE_NAME
```

##### Option 2: Access Keys

1. **Create a Kubernetes secret** with your AWS access key credentials:

```bash
kubectl create secret generic \
  --namespace causely aws-credentials \
  --from-literal=access-key-id="<your_access_key_id>" \
  --from-literal=secret-access-key="<your_secret_access_key>"
```

2. **Update your Causely configuration** by creating or updating `causely-values.yaml`:

```yaml
global:
  cluster_name: <your_cluster_name>
mediator:
  gateway:
    token: <your_token>
scrapers:
  aws:
    enabled: true
    accounts:
      - secretName: aws-credentials
        # namespace: causely  # optional; defaults to the pod namespace
```

3. **Upgrade your installation**:

```bash
helm upgrade --install causely \\
  --namespace=causely \\
  --values causely-values.yaml \\
  oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}"
```

:::tip Alternative: Credentials Autodiscovery

You can also use credentials autodiscovery by labeling the secret:

```bash
kubectl --namespace causely label secret aws-credentials "causely.ai/scraper=AWS"
```

This allows you to add new accounts without editing the configuration. See the [AWS integration documentation](/telemetry-sources/aws/) for more details.

:::

For complete setup instructions, including IAM role configuration and supported AWS services, see the [AWS integration documentation](/telemetry-sources/aws/).

### What to Expect

Once configured, Causely will:

- **Monitor Kubernetes services**: Using eBPF instrumentation, Causely automatically discovers and monitors services running in your Kubernetes cluster.

- **Monitor AWS resources**: Causely will discover and monitor AWS services including:
  - Application Load Balancer (ALB) and Network Load Balancer (NLB)
  - Amazon ECS, EC2, EBS
  - Amazon RDS, ElastiCache, MSK
  - AWS Lambda
  - And more

- **Unified view**: Causely creates a unified topology showing relationships between your Kubernetes services and AWS resources.

- **Show data in the UI**: Within a few minutes, you should start seeing entities appearing in the Causely UI at [https://portal.causely.app](https://portal.causely.app).

### Add More Telemetry Sources

To help Causely infer Diagnoses more effectively, connect additional telemetry sources. Visit the [Telemetry Sources](/telemetry-sources) page to learn about the data sources that Causely supports, including:

- [Prometheus](/telemetry-sources/prometheus/)
- [OpenTelemetry](/telemetry-sources/opentelemetry/)
- [Grafana](/telemetry-sources/grafana/)
- [Alertmanager](/telemetry-sources/alertmanager/)
- And many more

  ## Review Discovery

You have successfully installed Causely! Navigate to https://portal.causely.app to verify your environment has been
discovered. You should see entities populated in the [Topology](/in-action/topology) view:

If the entities and connections you are expecting to see are not appearing, go to the [Integrations](https://portal.causely.app/integrations) page
and check for any errors for the telemetry sources you have configured.

Errors in the integrations page will prevent Causely from discovering entities and connections in your environment. Follow the [troubleshooting steps](/telemetry-sources/troubleshooting) to resolve the errors.

  ## Connect Causely to AI Agents

Give your agents access to Causely's causal reasoning via the MCP server. Any MCP-compatible agent or assistant including Claude Code, Cursor, VS Code, HolmesGPT, or your own custom agent, can query root causes, service health, dependency maps, and reliability reports directly.

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Claude

    }
    description='Query root causes, service health, and dependency maps directly from Claude Code or Claude Desktop via the Causely MCP server.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Cursor

    }
    description='Investigate incidents and check service health without leaving your editor using the Causely MCP integration.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Codex

    }
    description="Connect OpenAI's coding agent to Causely's causal reasoning via MCP for system-aware reliability workflows."
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         HolmesGPT

    }
    description='Pre-built incident investigation agent with Causely MCP configured as its causal reasoning layer.'
  />

Visit the [agent integration](/agent-integration) page to get started.

:::tip Other Platforms Supported

While this quickstart guide focuses on Kubernetes, Causely also supports:

- **Container Orchestration**: [Nomad](/installation/nomad/), Docker, ECS
- **GitOps**: [Argo CD](/installation/argocd/), [Flux](/installation/flux/)
- **Virtual Machines**: Direct installation on VMs

For detailed installation instructions for these platforms, visit the [Installation Overview](/installation) page.

:::

---

## Azure Quickstart Guide

This quickstart guide will help you get Causely up and running on Azure. This setup deploys Causely in your Kubernetes cluster (including AKS) with eBPF instrumentation enabled, and connects it to your Azure subscription to monitor cloud resources.

### Get Your Installation Command

1. Log in to the [Causely portal](https://portal.causely.app).
2. Visit the [mediators page](https://portal.causely.app/agents).
3. Click the **"Add new"** button (or **"Add ➕"** button) on the mediators page.
4. In the instructions panel, you'll see the Helm installation command with your access token pre-filled.
5. Copy the complete Helm command. It will look similar to the example below.

:::info Example Command

The command you copy will include your specific access token and cluster name. Here's what it typically looks like:

```bash
export CAUSELY_TOKEN=<your_token>
export CAUSELY_CLUSTER_NAME=<your_cluster_name>
export CAUSELY_VERSION=<version>
helm upgrade --install causely \\
  --create-namespace oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}" \\
  --namespace=causely \\
  --set image.tag="${CAUSELY_VERSION}" \\
  --set global.cluster_name="\${CAUSELY_CLUSTER_NAME}" \\
  --set mediator.gateway.token="\${CAUSELY_TOKEN}"
```

:::

:::info Screenshot Placeholder

Screenshots of the mediators page, "Add new" button, and instructions panel will be added here.

:::

### Run the Installation Command

1. Open a terminal with `kubectl` configured to access your Kubernetes cluster.
2. Paste and run the Helm command you copied from the portal.
3. Wait for the installation to complete:

```bash
kubectl wait --for=condition=Ready pod -l app.kubernetes.io/part-of=causely -n causely --timeout=300s
```

:::info

By default, Causely will use [eBPF-based instrumentation](/telemetry-sources/ebpf) to automatically instrument your applications running in Kubernetes. This provides zero-effort observability without code changes.

:::

### Connect Your Azure Subscription

Now you need to configure Causely to monitor your Azure resources. You'll need a Service Principal (SPN) with Reader permissions on the subscriptions you want to monitor.

##### Step 5a: Create a Service Principal

Use the Azure CLI to create a Service Principal:

```bash
az ad sp create-for-rbac --name causely-spn --role reader --scopes /subscriptions/<your_subscription_id>
```

This will output credentials including `tenantId`, `clientId`, `clientSecret`, and `subscriptionId`.

##### Step 5b: Create a Kubernetes Secret

Save the Service Principal credentials in a Kubernetes Secret:

```bash
kubectl --namespace causely create secret generic spn-credentials \
  --from-literal=tenantId="<your_tenant_id>" \
  --from-literal=clientId="<your_client_id>" \
  --from-literal=clientSecret="<your_client_secret>" \
  --from-literal=subscriptionId="<your_subscription_id>"
```

##### Step 5c: Update Causely Configuration

Update your `causely-values.yaml` to enable Azure scraping. You can enable different Azure resource types:

```yaml
global:
  cluster_name: <your_cluster_name>
mediator:
  gateway:
    token: <your_token>
scrapers:
  azure: # Scrape VMs & Disks
    enabled: true
    subscriptions:
      - secretName: spn-credentials
        namespace: causely

  azurePostgres: # Scrape PostgreSQL Databases
    enabled: true
    subscriptions:
      - secretName: spn-credentials
        namespace: causely

  azureMysql: # Scrape MySQL Databases
    enabled: true
    subscriptions:
      - secretName: spn-credentials
        namespace: causely

  azureRedis: # Scrape Redis
    enabled: true
    subscriptions:
      - secretName: spn-credentials
        namespace: causely

  azureEventhub: # Scrape EventHub
    enabled: true
    subscriptions:
      - secretName: spn-credentials
        namespace: causely
```

Then upgrade your installation:

```bash
helm upgrade --install causely \\
  --namespace=causely \\
  --values causely-values.yaml \\
  oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}"
```

:::tip Alternative: Credentials Autodiscovery

You can also use credentials autodiscovery by labeling the secret for each scraper:

```bash
# Azure VMs & Disks
kubectl --namespace causely label secret spn-credentials "causely.ai/scraper=Azure"

# Azure PostgreSQL
kubectl --namespace causely label secret spn-credentials "causely.ai/scraper=AzurePostgres"

# Azure MySQL
kubectl --namespace causely label secret spn-credentials "causely.ai/scraper=AzureMysql"

# Azure Redis
kubectl --namespace causely label secret spn-credentials "causely.ai/scraper=AzureRedis"

# Azure EventHub
kubectl --namespace causely label secret spn-credentials "causely.ai/scraper=AzureEventHub"
```

This allows you to add new accounts without editing the configuration. See the [Azure integration documentation](/telemetry-sources/azure/) for more details.

:::

### What to Expect

Once configured, Causely will:

- **Monitor Kubernetes services**: Using eBPF instrumentation, Causely automatically discovers and monitors services running in your Kubernetes cluster.

- **Monitor Azure resources**: Causely will discover and monitor Azure resources including:
  - Virtual Machines and Disks
  - Azure PostgreSQL and MySQL databases
  - Azure Redis
  - Azure EventHub
  - And more

- **Unified view**: Causely creates a unified topology showing relationships between your Kubernetes services and Azure resources.

- **Show data in the UI**: Within a few minutes, you should start seeing entities appearing in the Causely UI at [https://portal.causely.app](https://portal.causely.app).

### Add More Telemetry Sources

To help Causely infer Diagnoses more effectively, connect additional telemetry sources. Visit the [Telemetry Sources](/telemetry-sources) page to learn about the data sources that Causely supports, including:

- [Prometheus](/telemetry-sources/prometheus/)
- [OpenTelemetry](/telemetry-sources/opentelemetry/)
- [Grafana](/telemetry-sources/grafana/)
- [Alertmanager](/telemetry-sources/alertmanager/)
- And many more

  ## Review Discovery

You have successfully installed Causely! Navigate to https://portal.causely.app to verify your environment has been
discovered. You should see entities populated in the [Topology](/in-action/topology) view:

If the entities and connections you are expecting to see are not appearing, go to the [Integrations](https://portal.causely.app/integrations) page
and check for any errors for the telemetry sources you have configured.

Errors in the integrations page will prevent Causely from discovering entities and connections in your environment. Follow the [troubleshooting steps](/telemetry-sources/troubleshooting) to resolve the errors.

  ## Connect Causely to AI Agents

Give your agents access to Causely's causal reasoning via the MCP server. Any MCP-compatible agent or assistant including Claude Code, Cursor, VS Code, HolmesGPT, or your own custom agent, can query root causes, service health, dependency maps, and reliability reports directly.

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Claude

    }
    description='Query root causes, service health, and dependency maps directly from Claude Code or Claude Desktop via the Causely MCP server.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Cursor

    }
    description='Investigate incidents and check service health without leaving your editor using the Causely MCP integration.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Codex

    }
    description="Connect OpenAI's coding agent to Causely's causal reasoning via MCP for system-aware reliability workflows."
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         HolmesGPT

    }
    description='Pre-built incident investigation agent with Causely MCP configured as its causal reasoning layer.'
  />

Visit the [agent integration](/agent-integration) page to get started.

:::tip Other Platforms Supported

While this quickstart guide focuses on Kubernetes, Causely also supports:

- **Container Orchestration**: [Nomad](/installation/nomad/), Docker, ECS
- **GitOps**: [Argo CD](/installation/argocd/), [Flux](/installation/flux/)
- **Virtual Machines**: Direct installation on VMs

For detailed installation instructions for these platforms, visit the [Installation Overview](/installation) page.

:::

---

## Datadog Quickstart Guide

This quickstart guide will help you get Causely up and running with Datadog. This setup uses Datadog APM with dual shipping to send traces to Causely while continuing to send data to Datadog.

:::tip Alternative to dual shipping
Causely can also discover your infrastructure and application services from the Datadog API, without dual shipping. See [Discover infrastructure and application services from the Datadog API](/telemetry-sources/datadog#discover-infrastructure-and-application-services-from-the-datadog-api).
:::

### Get Your Installation Command

1. Log in to the [Causely portal](https://portal.causely.app).
2. Visit the [mediators page](https://portal.causely.app/agents).
3. Click the **"Add new"** button (or **"Add ➕"** button) on the mediators page.
4. In the instructions panel, you'll see the Helm installation command with your access token pre-filled.
5. Copy the complete Helm command. It will look similar to the example below.

:::info Example Command

The command you copy will include your specific access token and cluster name. Here's what it typically looks like:

```bash
export CAUSELY_TOKEN=<your_token>
export CAUSELY_CLUSTER_NAME=<your_cluster_name>
export CAUSELY_VERSION=<version>
helm upgrade --install causely \\
  --create-namespace oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}" \\
  --namespace=causely \\
  --set image.tag="${CAUSELY_VERSION}" \\
  --set global.cluster_name="\${CAUSELY_CLUSTER_NAME}" \\
  --set mediator.gateway.token="\${CAUSELY_TOKEN}"
```

:::

:::info Screenshot Placeholder

Screenshots of the mediators page, "Add new" button, and instructions panel will be added here.

:::

### Create a Values File to Disable eBPF

Since you'll be using Datadog for instrumentation, create a `causely-values.yaml` file to disable eBPF instrumentation:

```yaml
global:
  cluster_name: <your_cluster_name>
mediator:
  gateway:
    token: <your_token>
scrapers:
  bpf:
    enabled: false
```

Replace `<your_cluster_name>` and `<your_token>` with your actual values from the portal.

### Run the Installation Command

1. Open a terminal with `kubectl` configured to access your cluster.
2. Run the Helm command with your values file:

```bash
export CAUSELY_VERSION=<version>
helm upgrade --install causely \\
  --create-namespace oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}" \\
  --namespace=causely \\
  --set image.tag="${CAUSELY_VERSION}" \\
  --set global.cluster_name="<your_cluster_name>" \\
  --set mediator.gateway.token="<your_token>" \\
  --values causely-values.yaml
```

3. Wait for the installation to complete:

```bash
kubectl wait --for=condition=Ready pod -l app.kubernetes.io/part-of=causely -n causely --timeout=300s
```

### Configure Datadog Dual Shipping

Now you need to configure your Datadog Agent to send traces to Causely using [dual shipping](https://docs.datadoghq.com/agent/configuration/dual-shipping/).

##### Option 1: If using Helm to deploy Datadog

Add the following to your Datadog `values.yaml`:

```yaml
agents:
  useConfigMap: true
  customAgentConfig:
    apm_config:
      additional_endpoints:
        'http://mediator.causely:8126':
          - 'datadog-receiver'
```

Then upgrade your Datadog installation:

```bash
helm upgrade --install datadog datadog/datadog -f ./values.yaml
```

##### Option 2: If using the Datadog Operator

Modify your `DatadogAgent` custom resource:

```yaml
apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  override:
    nodeAgent:
      env:
        - name: DD_APM_ADDITIONAL_ENDPOINTS
          value: '{"http://mediator.causely:8126": ["datadog-receiver"]}'
```

For more details, see the [Datadog integration documentation](/telemetry-sources/datadog/).

### What to Expect

Once configured, Causely will:

- **Receive Datadog traces**: Your Datadog Agent will send traces to Causely's mediator via dual shipping.
- **Discover service dependencies**: Causely will automatically discover service dependencies from your Datadog APM traces.
- **Show data in the UI**: Within a few minutes, you should start seeing services and their relationships appearing in the Causely UI at [https://portal.causely.app](https://portal.causely.app).

:::tip

You can also enable Datadog monitors as a data source for additional insights. See the [Datadog integration documentation](/telemetry-sources/datadog/) for details.

:::

### Add More Telemetry Sources

To help Causely infer Diagnoses more effectively, connect additional telemetry sources. Visit the [Telemetry Sources](/telemetry-sources) page to learn about the data sources that Causely supports, including:

- [Prometheus](/telemetry-sources/prometheus/)
- [OpenTelemetry](/telemetry-sources/opentelemetry/)
- [Grafana](/telemetry-sources/grafana/)
- [Alertmanager](/telemetry-sources/alertmanager/)
- And many more

  ## Review Discovery

You have successfully installed Causely! Navigate to https://portal.causely.app to verify your environment has been
discovered. You should see entities populated in the [Topology](/in-action/topology) view:

If the entities and connections you are expecting to see are not appearing, go to the [Integrations](https://portal.causely.app/integrations) page
and check for any errors for the telemetry sources you have configured.

Errors in the integrations page will prevent Causely from discovering entities and connections in your environment. Follow the [troubleshooting steps](/telemetry-sources/troubleshooting) to resolve the errors.

  ## Connect Causely to AI Agents

Give your agents access to Causely's causal reasoning via the MCP server. Any MCP-compatible agent or assistant including Claude Code, Cursor, VS Code, HolmesGPT, or your own custom agent, can query root causes, service health, dependency maps, and reliability reports directly.

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Claude

    }
    description='Query root causes, service health, and dependency maps directly from Claude Code or Claude Desktop via the Causely MCP server.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Cursor

    }
    description='Investigate incidents and check service health without leaving your editor using the Causely MCP integration.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Codex

    }
    description="Connect OpenAI's coding agent to Causely's causal reasoning via MCP for system-aware reliability workflows."
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         HolmesGPT

    }
    description='Pre-built incident investigation agent with Causely MCP configured as its causal reasoning layer.'
  />

Visit the [agent integration](/agent-integration) page to get started.

:::tip Other Platforms Supported

While this quickstart guide focuses on Kubernetes, Causely also supports:

- **Container Orchestration**: [Nomad](/installation/nomad/), Docker, ECS
- **GitOps**: [Argo CD](/installation/argocd/), [Flux](/installation/flux/)
- **Virtual Machines**: Direct installation on VMs

For detailed installation instructions for these platforms, visit the [Installation Overview](/installation) page.

:::

---

## Dynatrace Quickstart Guide

This quickstart guide will help you get Causely up and running with Dynatrace. This setup allows Causely to ingest service dependencies and traces from Kubernetes and ECS environments, and infrastructure and dataflow data from environments such as VMware, creating a unified causality graph. Causely also maps your existing Dynatrace infrastructure alerts to infrastructure Signals.

### Get Your Installation Command

1. Log in to the [Causely portal](https://portal.causely.app).
2. Visit the [mediators page](https://portal.causely.app/agents).
3. Click the **"Add new"** button (or **"Add ➕"** button) on the mediators page.
4. In the instructions panel, you'll see the Helm installation command with your access token pre-filled.
5. Copy the complete Helm command. It will look similar to the example below.

:::info Example Command

The command you copy will include your specific access token and cluster name. Here's what it typically looks like:

```bash
export CAUSELY_TOKEN=<your_token>
export CAUSELY_CLUSTER_NAME=<your_cluster_name>
export CAUSELY_VERSION=<version>
helm upgrade --install causely \\
  --create-namespace oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}" \\
  --namespace=causely \\
  --set image.tag="${CAUSELY_VERSION}" \\
  --set global.cluster_name="\${CAUSELY_CLUSTER_NAME}" \\
  --set mediator.gateway.token="\${CAUSELY_TOKEN}"
```

:::

:::info Screenshot Placeholder

Screenshots of the mediators page, "Add new" button, and instructions panel will be added here.

:::

### Create a Values File to Disable eBPF

Since you'll be using Dynatrace for instrumentation, create a `causely-values.yaml` file to disable eBPF instrumentation:

```yaml
global:
  cluster_name: <your_cluster_name>
mediator:
  gateway:
    token: <your_token>
scrapers:
  bpf:
    enabled: false
```

Replace `<your_cluster_name>` and `<your_token>` with your actual values from the portal.

### Run the Installation Command

1. Open a terminal with `kubectl` configured to access your cluster.
2. Run the Helm command with your values file:

```bash
export CAUSELY_VERSION=<version>
helm upgrade --install causely \\
  --create-namespace oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}" \\
  --namespace=causely \\
  --set image.tag="${CAUSELY_VERSION}" \\
  --set global.cluster_name="<your_cluster_name>" \\
  --set mediator.gateway.token="<your_token>" \\
  --values causely-values.yaml
```

3. Wait for the installation to complete:

```bash
kubectl wait --for=condition=Ready pod -l app.kubernetes.io/part-of=causely -n causely --timeout=300s
```

### Configure Dynatrace Integration

Now you need to configure Causely to scrape data from your Dynatrace account.

##### Step 6a: Create a Kubernetes Secret

Create a Kubernetes secret with your Dynatrace URL and API token:

```bash
kubectl create secret generic \
  --namespace causely dynatrace-credentials \
  --from-literal=url="<your_dynatrace_url>" \
  --from-literal=api-token="<your_dynatrace_api_token>"
```

##### Step 6b: Update Causely Configuration

Update your `causely-values.yaml` to enable Dynatrace scraping:

```yaml
global:
  cluster_name: <your_cluster_name>
mediator:
  gateway:
    token: <your_token>
scrapers:
  bpf:
    enabled: false
  dynatrace:
    enabled: true
    accounts:
      - secretName: dynatrace-credentials
```

Then upgrade your Causely installation:

```bash
helm upgrade --install causely \\
  --namespace=causely \\
  --values causely-values.yaml \\
  oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}"
```

:::tip Alternative: Credentials Autodiscovery

You can also use credentials autodiscovery by labeling the secret:

```bash
kubectl --namespace causely label secret dynatrace-credentials "causely.ai/scraper=Dynatrace"
```

This allows you to add new accounts without editing the configuration. See the [Dynatrace integration documentation](/telemetry-sources/dynatrace/) for more details.

:::

### What to Expect

Once configured, Causely will:

- **Ingest Dynatrace topology and telemetry**: Causely will scrape service dependencies and traces from your Dynatrace account.
- **Unified view across platforms**: If you have both Kubernetes and ECS services, Causely will automatically discover and model dependencies between them, creating a unified causal view.
- **Map infrastructure coverage**: Causely will ingest how your application components map to underlying infrastructure, including VMware hosts, and map Dynatrace infrastructure alerts to Causely Signals.
- **Show data in the UI**: Within a few minutes, you should start seeing your Dynatrace-monitored services, such as Kubernetes and ECS services, appearing in the Causely UI at [https://portal.causely.app](https://portal.causely.app).

For more details on how Causely unifies data across platforms, see the [Dynatrace integration documentation](/telemetry-sources/dynatrace/).

### Add More Telemetry Sources

To help Causely infer Diagnoses more effectively, connect additional telemetry sources. Visit the [Telemetry Sources](/telemetry-sources) page to learn about the data sources that Causely supports, including:

- [Prometheus](/telemetry-sources/prometheus/)
- [OpenTelemetry](/telemetry-sources/opentelemetry/)
- [Grafana](/telemetry-sources/grafana/)
- [Alertmanager](/telemetry-sources/alertmanager/)
- And many more

  ## Review Discovery

You have successfully installed Causely! Navigate to https://portal.causely.app to verify your environment has been
discovered. You should see entities populated in the [Topology](/in-action/topology) view:

If the entities and connections you are expecting to see are not appearing, go to the [Integrations](https://portal.causely.app/integrations) page
and check for any errors for the telemetry sources you have configured.

Errors in the integrations page will prevent Causely from discovering entities and connections in your environment. Follow the [troubleshooting steps](/telemetry-sources/troubleshooting) to resolve the errors.

  ## Connect Causely to AI Agents

Give your agents access to Causely's causal reasoning via the MCP server. Any MCP-compatible agent or assistant including Claude Code, Cursor, VS Code, HolmesGPT, or your own custom agent, can query root causes, service health, dependency maps, and reliability reports directly.

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Claude

    }
    description='Query root causes, service health, and dependency maps directly from Claude Code or Claude Desktop via the Causely MCP server.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Cursor

    }
    description='Investigate incidents and check service health without leaving your editor using the Causely MCP integration.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Codex

    }
    description="Connect OpenAI's coding agent to Causely's causal reasoning via MCP for system-aware reliability workflows."
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         HolmesGPT

    }
    description='Pre-built incident investigation agent with Causely MCP configured as its causal reasoning layer.'
  />

Visit the [agent integration](/agent-integration) page to get started.

:::tip Other Platforms Supported

While this quickstart guide focuses on Kubernetes, Causely also supports:

- **Container Orchestration**: [Nomad](/installation/nomad/), [Docker](/installation/docker/), ECS
- **Dynatrace-monitored environments**: ECS, VMware, and other on-prem or host-based environments (see the [Dynatrace integration](/telemetry-sources/dynatrace/))
- **GitOps**: [Argo CD](/installation/argocd/), [Flux](/installation/flux/)
- **Virtual Machines**: Direct installation on VMs

For detailed installation instructions for these platforms, visit the [Installation Overview](/installation) page.

:::

---

## GCP Quickstart Guide

This quickstart guide will help you get Causely up and running on GCP. This setup deploys Causely in your Kubernetes cluster (including GKE) with eBPF instrumentation enabled, and connects it to your GCP project to monitor cloud resources.

### Get Your Installation Command

1. Log in to the [Causely portal](https://portal.causely.app).
2. Visit the [mediators page](https://portal.causely.app/agents).
3. Click the **"Add new"** button (or **"Add ➕"** button) on the mediators page.
4. In the instructions panel, you'll see the Helm installation command with your access token pre-filled.
5. Copy the complete Helm command. It will look similar to the example below.

:::info Example Command

The command you copy will include your specific access token and cluster name. Here's what it typically looks like:

```bash
export CAUSELY_TOKEN=<your_token>
export CAUSELY_CLUSTER_NAME=<your_cluster_name>
export CAUSELY_VERSION=<version>
helm upgrade --install causely \\
  --create-namespace oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}" \\
  --namespace=causely \\
  --set image.tag="${CAUSELY_VERSION}" \\
  --set global.cluster_name="\${CAUSELY_CLUSTER_NAME}" \\
  --set mediator.gateway.token="\${CAUSELY_TOKEN}"
```

:::

:::info Screenshot Placeholder

Screenshots of the mediators page, "Add new" button, and instructions panel will be added here.

:::

### Run the Installation Command

1. Open a terminal with `kubectl` configured to access your Kubernetes cluster.
2. Paste and run the Helm command you copied from the portal.
3. Wait for the installation to complete:

```bash
kubectl wait --for=condition=Ready pod -l app.kubernetes.io/part-of=causely -n causely --timeout=300s
```

:::info

By default, Causely will use [eBPF-based instrumentation](/telemetry-sources/ebpf) to automatically instrument your applications running in Kubernetes. This provides zero-effort observability without code changes.

:::

### Connect Your GCP Project

Now you need to configure Causely to monitor your GCP resources. You'll need a Service Account with Viewer permissions on the projects you want to monitor.

##### Step 5a: Create a Service Account

Use the `gcloud` CLI to create a Service Account:

```bash
gcloud iam service-accounts create causely \
  --description="Causely service account" \
  --display-name="Causely"

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:causely@PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/viewer"

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:causely@PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/monitoring.viewer"

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:causely@PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/bigtable.viewer"
```

##### Step 5b: Create and Download Service Account Key

Create a key for the Service Account and download it:

```bash
gcloud iam service-accounts keys create service_account.json \
  --iam-account=causely@PROJECT_ID.iam.gserviceaccount.com
```

##### Step 5c: Create a Kubernetes Secret

Save the Service Account credentials in a Kubernetes Secret:

```bash
kubectl create secret --namespace causely generic gcp-credentials \
  --from-file=service_account.json=service_account.json \
  --from-literal=project_id=PROJECT_ID
```

##### Step 5d: Update Causely Configuration

Update your `causely-values.yaml` to enable GCP scraping:

```yaml
global:
  cluster_name: <your_cluster_name>
mediator:
  gateway:
    token: <your_token>
scrapers:
  gcp:
    enabled: true
    projects:
      - secretName: gcp-credentials
        namespace: causely
```

Then upgrade your installation:

```bash
helm upgrade --install causely \\
  --namespace=causely \\
  --values causely-values.yaml \\
  oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}"
```

:::tip Alternative: Credentials Autodiscovery

You can also use credentials autodiscovery by labeling the secret:

```bash
kubectl --namespace causely label secret gcp-credentials "causely.ai/scraper=GCP"
```

This allows you to add new projects without editing the configuration. See the [GCP integration documentation](/telemetry-sources/gcp/) for more details.

:::

For complete setup instructions and information about which GCP resources are supported, see the [GCP integration documentation](/telemetry-sources/gcp/).

### What to Expect

Once configured, Causely will:

- **Monitor Kubernetes services**: Using eBPF instrumentation, Causely automatically discovers and monitors services running in your Kubernetes cluster.

- **Monitor GCP resources**: Causely will discover and monitor GCP resources including:
  - Compute Engine instances
  - Cloud SQL databases
  - Cloud Storage
  - Bigtable
  - And more

- **Unified view**: Causely creates a unified topology showing relationships between your Kubernetes services and GCP resources.

- **Show data in the UI**: Within a few minutes, you should start seeing entities appearing in the Causely UI at [https://portal.causely.app](https://portal.causely.app).

### Add More Telemetry Sources

To help Causely infer Diagnoses more effectively, connect additional telemetry sources. Visit the [Telemetry Sources](/telemetry-sources) page to learn about the data sources that Causely supports, including:

- [Prometheus](/telemetry-sources/prometheus/)
- [OpenTelemetry](/telemetry-sources/opentelemetry/)
- [Grafana](/telemetry-sources/grafana/)
- [Alertmanager](/telemetry-sources/alertmanager/)
- And many more

  ## Review Discovery

You have successfully installed Causely! Navigate to https://portal.causely.app to verify your environment has been
discovered. You should see entities populated in the [Topology](/in-action/topology) view:

If the entities and connections you are expecting to see are not appearing, go to the [Integrations](https://portal.causely.app/integrations) page
and check for any errors for the telemetry sources you have configured.

Errors in the integrations page will prevent Causely from discovering entities and connections in your environment. Follow the [troubleshooting steps](/telemetry-sources/troubleshooting) to resolve the errors.

  ## Connect Causely to AI Agents

Give your agents access to Causely's causal reasoning via the MCP server. Any MCP-compatible agent or assistant including Claude Code, Cursor, VS Code, HolmesGPT, or your own custom agent, can query root causes, service health, dependency maps, and reliability reports directly.

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Claude

    }
    description='Query root causes, service health, and dependency maps directly from Claude Code or Claude Desktop via the Causely MCP server.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Cursor

    }
    description='Investigate incidents and check service health without leaving your editor using the Causely MCP integration.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Codex

    }
    description="Connect OpenAI's coding agent to Causely's causal reasoning via MCP for system-aware reliability workflows."
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         HolmesGPT

    }
    description='Pre-built incident investigation agent with Causely MCP configured as its causal reasoning layer.'
  />

Visit the [agent integration](/agent-integration) page to get started.

:::tip Other Platforms Supported

While this quickstart guide focuses on Kubernetes, Causely also supports:

- **Container Orchestration**: [Nomad](/installation/nomad/), Docker, ECS
- **GitOps**: [Argo CD](/installation/argocd/), [Flux](/installation/flux/)
- **Virtual Machines**: Direct installation on VMs

For detailed installation instructions for these platforms, visit the [Installation Overview](/installation) page.

:::

---

## Instana Quickstart Guide

This quickstart guide will help you get Causely up and running with Instana. This setup allows Causely to ingest service dependencies, traces, and metrics from Instana to build a unified causality graph.

### Get Your Installation Command

1. Log in to the [Causely portal](https://portal.causely.app).
2. Visit the [mediators page](https://portal.causely.app/agents).
3. Click the **"Add new"** button (or **"Add ➕"** button) on the mediators page.
4. In the instructions panel, you'll see the Helm installation command with your access token pre-filled.
5. Copy the complete Helm command. It will look similar to the example below.

:::info Example Command

The command you copy will include your specific access token and cluster name. Here's what it typically looks like:

```bash
export CAUSELY_TOKEN=<your_token>
export CAUSELY_CLUSTER_NAME=<your_cluster_name>
export CAUSELY_VERSION=<version>
helm upgrade --install causely \\
  --create-namespace oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}" \\
  --namespace=causely \\
  --set image.tag="${CAUSELY_VERSION}" \\
  --set global.cluster_name="\${CAUSELY_CLUSTER_NAME}" \\
  --set mediator.gateway.token="\${CAUSELY_TOKEN}"
```

:::

:::info Screenshot Placeholder

Screenshots of the mediators page, "Add new" button, and instructions panel will be added here.

:::

### Create a Values File to Disable eBPF

Since you'll be using Instana for instrumentation, create a `causely-values.yaml` file to disable eBPF instrumentation:

```yaml
global:
  cluster_name: <your_cluster_name>
mediator:
  gateway:
    token: <your_token>
scrapers:
  bpf:
    enabled: false
```

Replace `<your_cluster_name>` and `<your_token>` with your actual values from the portal.

### Run the Installation Command

1. Open a terminal with `kubectl` configured to access your cluster.
2. Run the Helm command with your values file:

```bash
export CAUSELY_VERSION=<version>
helm upgrade --install causely \\
  --create-namespace oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}" \\
  --namespace=causely \\
  --set image.tag="${CAUSELY_VERSION}" \\
  --set global.cluster_name="<your_cluster_name>" \\
  --set mediator.gateway.token="<your_token>" \\
  --values causely-values.yaml
```

3. Wait for the installation to complete:

```bash
kubectl wait --for=condition=Ready pod -l app.kubernetes.io/part-of=causely -n causely --timeout=300s
```

### Configure Instana Integration

Now you need to configure Causely to scrape data from your Instana account.

##### Step 6a: Create an API Token in Instana

1. Log in to your Instana instance.
2. Create an API token with read access to applications, endpoints, metrics, and infrastructure.

##### Step 6b: Create a Kubernetes Secret

Create a Kubernetes secret with your Instana URL and API token:

```bash
kubectl create secret generic \
  --namespace causely instana-credentials \
  --from-literal=url="https://your-instana.example.com" \
  --from-literal=api-token="<your_instana_api_token>"
```

If your Instana instance uses a self-signed certificate, you can optionally add:

```bash
  --from-literal=insecure-skip-verify="true"
```

##### Step 6c: Update Causely Configuration

Update your `causely-values.yaml` to enable Instana scraping:

```yaml
global:
  cluster_name: <your_cluster_name>
mediator:
  gateway:
    token: <your_token>
scrapers:
  bpf:
    enabled: false
  instana:
    enabled: true
    accounts:
      - secretName: instana-credentials
        # namespace: causely  # optional; defaults to the pod namespace
```

Then upgrade your Causely installation:

```bash
helm upgrade --install causely \\
  --namespace=causely \\
  --values causely-values.yaml \\
  oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}"
```

:::tip Alternative: Credentials Autodiscovery

You can also use credentials autodiscovery by labeling the secret:

```bash
kubectl --namespace causely label secret instana-credentials "causely.ai/scraper=Instana"
```

This allows you to add new accounts without editing the configuration. See the [Instana integration documentation](/telemetry-sources/instana/) for more details.

:::

### What to Expect

Once configured, Causely will:

- **Ingest Instana data**: Causely will scrape service dependencies, traces, metrics, and topology from your Instana account.
- **Discover service dependencies**: Causely automatically discovers service dependencies and maps them to Kubernetes workloads.
- **Collect endpoint metrics**: HTTP paths, RPC methods, and their metrics (requests, errors, latency) are collected and analyzed.
- **Database insights**: Database queries and access patterns are discovered and mapped to services.
- **Show data in the UI**: Within a few minutes, you should start seeing services, endpoints, and their relationships appearing in the Causely UI at [https://portal.causely.app](https://portal.causely.app).

For more details on what data is collected, see the [Instana integration documentation](/telemetry-sources/instana/).

### Add More Telemetry Sources

To help Causely infer Diagnoses more effectively, connect additional telemetry sources. Visit the [Telemetry Sources](/telemetry-sources) page to learn about the data sources that Causely supports, including:

- [Prometheus](/telemetry-sources/prometheus/)
- [OpenTelemetry](/telemetry-sources/opentelemetry/)
- [Grafana](/telemetry-sources/grafana/)
- [Alertmanager](/telemetry-sources/alertmanager/)
- And many more

  ## Review Discovery

You have successfully installed Causely! Navigate to https://portal.causely.app to verify your environment has been
discovered. You should see entities populated in the [Topology](/in-action/topology) view:

If the entities and connections you are expecting to see are not appearing, go to the [Integrations](https://portal.causely.app/integrations) page
and check for any errors for the telemetry sources you have configured.

Errors in the integrations page will prevent Causely from discovering entities and connections in your environment. Follow the [troubleshooting steps](/telemetry-sources/troubleshooting) to resolve the errors.

  ## Connect Causely to AI Agents

Give your agents access to Causely's causal reasoning via the MCP server. Any MCP-compatible agent or assistant including Claude Code, Cursor, VS Code, HolmesGPT, or your own custom agent, can query root causes, service health, dependency maps, and reliability reports directly.

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Claude

    }
    description='Query root causes, service health, and dependency maps directly from Claude Code or Claude Desktop via the Causely MCP server.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Cursor

    }
    description='Investigate incidents and check service health without leaving your editor using the Causely MCP integration.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Codex

    }
    description="Connect OpenAI's coding agent to Causely's causal reasoning via MCP for system-aware reliability workflows."
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         HolmesGPT

    }
    description='Pre-built incident investigation agent with Causely MCP configured as its causal reasoning layer.'
  />

Visit the [agent integration](/agent-integration) page to get started.

:::tip Other Platforms Supported

While this quickstart guide focuses on Kubernetes, Causely also supports:

- **Container Orchestration**: [Nomad](/installation/nomad/), Docker, ECS
- **GitOps**: [Argo CD](/installation/argocd/), [Flux](/installation/flux/)
- **Virtual Machines**: Direct installation on VMs

For detailed installation instructions for these platforms, visit the [Installation Overview](/installation) page.

:::

---

## Kubernetes Quickstart Guide

This quickstart guide will help you get Causely up and running on your Kubernetes cluster in just a few minutes. By the end of this guide, you'll have Causely installed and collecting telemetry data from your cluster.

### Get Your Installation Command

1. Log in to the [Causely portal](https://portal.causely.app).
2. Visit the [mediators page](https://portal.causely.app/agents).
3. Click the **"Add new"** button (or **"Add ➕"** button) on the mediators page.
4. In the instructions panel, you'll see the Helm installation command with your access token pre-filled.
5. Copy the complete Helm command. It will look similar to the example below.

:::info Example Command

The command you copy will include your specific access token and cluster name. Here's what it typically looks like:

```bash
export CAUSELY_TOKEN=<your_token>
export CAUSELY_CLUSTER_NAME=<your_cluster_name>
export CAUSELY_VERSION=<version>
helm upgrade --install causely \\
  --create-namespace oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}" \\
  --namespace=causely \\
  --set image.tag="${CAUSELY_VERSION}" \\
  --set global.cluster_name="\${CAUSELY_CLUSTER_NAME}" \\
  --set mediator.gateway.token="\${CAUSELY_TOKEN}"
```

:::

:::info Screenshot Placeholder

Screenshots of the mediators page, "Add new" button, and instructions panel will be added here.

:::

### Run the Installation Command

1. Open a terminal with `kubectl` configured to access your cluster.
2. Paste and run the Helm command you copied from the portal.
3. Wait for the installation to complete. You can monitor the progress with:

```bash
kubectl wait --for=condition=Ready pod -l app.kubernetes.io/part-of=causely -n causely --timeout=300s
```

### What to Expect

Once the installation is complete, Causely will automatically:

- **Enable eBPF-based instrumentation**: Causely uses [OpenTelemetry eBPF instrumentation](/telemetry-sources/ebpf), powered by Grafana Beyla, to automatically instrument your applications without requiring code changes. This provides zero-effort observability for services running in your cluster.

- **Start collecting telemetry**: The agent will begin discovering services, pods, and their dependencies in your cluster.

- **Show data in the UI**: Within a few minutes, you should start seeing entities appearing in the Causely UI at [https://portal.causely.app](https://portal.causely.app). Services, pods, and their relationships will be automatically discovered and displayed in the topology graph.

:::tip

If you don't see entities appearing after a few minutes, check the mediator logs:

```bash
kubectl logs -n causely \
             -l app.kubernetes.io/name=mediator \
             -c mediator \
             --tail=-1 | grep ERROR
```

:::

### Add More Telemetry Sources

To help Causely infer Diagnoses more effectively, connect additional telemetry sources. Visit the [Telemetry Sources](/telemetry-sources) page to learn about the data sources that Causely supports, including:

- [Prometheus](/telemetry-sources/prometheus/)
- [OpenTelemetry](/telemetry-sources/opentelemetry/)
- [Grafana](/telemetry-sources/grafana/)
- [Alertmanager](/telemetry-sources/alertmanager/)
- And many more

  ## Review Discovery

You have successfully installed Causely! Navigate to https://portal.causely.app to verify your environment has been
discovered. You should see entities populated in the [Topology](/in-action/topology) view:

If the entities and connections you are expecting to see are not appearing, go to the [Integrations](https://portal.causely.app/integrations) page
and check for any errors for the telemetry sources you have configured.

Errors in the integrations page will prevent Causely from discovering entities and connections in your environment. Follow the [troubleshooting steps](/telemetry-sources/troubleshooting) to resolve the errors.

  ## Connect Causely to AI Agents

Give your agents access to Causely's causal reasoning via the MCP server. Any MCP-compatible agent or assistant including Claude Code, Cursor, VS Code, HolmesGPT, or your own custom agent, can query root causes, service health, dependency maps, and reliability reports directly.

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Claude

    }
    description='Query root causes, service health, and dependency maps directly from Claude Code or Claude Desktop via the Causely MCP server.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Cursor

    }
    description='Investigate incidents and check service health without leaving your editor using the Causely MCP integration.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Codex

    }
    description="Connect OpenAI's coding agent to Causely's causal reasoning via MCP for system-aware reliability workflows."
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         HolmesGPT

    }
    description='Pre-built incident investigation agent with Causely MCP configured as its causal reasoning layer.'
  />

Visit the [agent integration](/agent-integration) page to get started.

:::tip Other Platforms Supported

While this quickstart guide focuses on Kubernetes, Causely also supports:

- **Container Orchestration**: [Nomad](/installation/nomad/), Docker, ECS
- **GitOps**: [Argo CD](/installation/argocd/), [Flux](/installation/flux/)
- **Virtual Machines**: Direct installation on VMs

For detailed installation instructions for these platforms, visit the [Installation Overview](/installation) page.

:::

---

## OpenTelemetry Quickstart Guide

This quickstart guide will help you get Causely up and running with OpenTelemetry. This setup is ideal if you're already using OpenTelemetry instrumentation or want to use your existing OpenTelemetry Collector.

### Get Your Installation Command

1. Log in to the [Causely portal](https://portal.causely.app).
2. Visit the [mediators page](https://portal.causely.app/agents).
3. Click the **"Add new"** button (or **"Add ➕"** button) on the mediators page.
4. In the instructions panel, you'll see the Helm installation command with your access token pre-filled.
5. Copy the complete Helm command. It will look similar to the example below.

:::info Example Command

The command you copy will include your specific access token and cluster name. Here's what it typically looks like:

```bash
export CAUSELY_TOKEN=<your_token>
export CAUSELY_CLUSTER_NAME=<your_cluster_name>
export CAUSELY_VERSION=<version>
helm upgrade --install causely \\
  --create-namespace oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}" \\
  --namespace=causely \\
  --set image.tag="${CAUSELY_VERSION}" \\
  --set global.cluster_name="\${CAUSELY_CLUSTER_NAME}" \\
  --set mediator.gateway.token="\${CAUSELY_TOKEN}"
```

:::

:::info Screenshot Placeholder

Screenshots of the mediators page, "Add new" button, and instructions panel will be added here.

:::

### Create a Values File to Configure OpenTelemetry

Create a `causely-values.yaml` file with the following configuration to disable eBPF instrumentation and configure OpenTelemetry:

```yaml
global:
  cluster_name: <your_cluster_name>
mediator:
  gateway:
    token: <your_token>
scrapers:
  bpf:
    enabled: false
```

Replace `<your_cluster_name>` and `<your_token>` with your actual values from the portal.

### Run the Installation Command

1. Open a terminal with `kubectl` configured to access your cluster.
2. Run the Helm command with your values file:

```bash
export CAUSELY_VERSION=<version>
helm upgrade --install causely \\
  --create-namespace oci://us-docker.pkg.dev/public-causely/public/causely \\
  --version "${CAUSELY_VERSION}" \\
  --namespace=causely \\
  --set image.tag="${CAUSELY_VERSION}" \\
  --set global.cluster_name="<your_cluster_name>" \\
  --set mediator.gateway.token="<your_token>" \\
  --values causely-values.yaml
```

3. Wait for the installation to complete:

```bash
kubectl wait --for=condition=Ready pod -l app.kubernetes.io/part-of=causely -n causely --timeout=300s
```

### Configure Your OpenTelemetry Collector

Now you need to configure your OpenTelemetry Collector to send traces and metrics to Causely's mediator. The mediator listens for OpenTelemetry Protocol (OTLP) data on port `4317`.

If you don't have an OpenTelemetry Collector running, you can install one using the [OpenTelemetry Operator](https://opentelemetry.io/docs/platforms/kubernetes/operator/). For detailed configuration instructions, see the [OpenTelemetry integration guide](/telemetry-sources/opentelemetry/).

The key configuration you'll need is to add an exporter that points to the Causely mediator:

```yaml
exporters:
  otlp/causely:
    endpoint: mediator.causely:4317
    compression: none
    tls:
      insecure: true
```

### What to Expect

Once configured, Causely will:

- **Receive OpenTelemetry data**: Your OpenTelemetry Collector will send traces and metrics to the Causely mediator.
- **Discover service dependencies**: Causely will automatically discover service dependencies from your OpenTelemetry traces.
- **Show data in the UI**: Within a few minutes, you should start seeing services and their relationships appearing in the Causely UI at [https://portal.causely.app](https://portal.causely.app).

:::tip

For complete OpenTelemetry configuration examples, including Kubernetes attributes processing and filtering, see the [OpenTelemetry integration documentation](/telemetry-sources/opentelemetry/).

:::

### Add More Telemetry Sources

To help Causely infer Diagnoses more effectively, connect additional telemetry sources. Visit the [Telemetry Sources](/telemetry-sources) page to learn about the data sources that Causely supports, including:

- [Prometheus](/telemetry-sources/prometheus/)
- [OpenTelemetry](/telemetry-sources/opentelemetry/)
- [Grafana](/telemetry-sources/grafana/)
- [Alertmanager](/telemetry-sources/alertmanager/)
- And many more

  ## Review Discovery

You have successfully installed Causely! Navigate to https://portal.causely.app to verify your environment has been
discovered. You should see entities populated in the [Topology](/in-action/topology) view:

If the entities and connections you are expecting to see are not appearing, go to the [Integrations](https://portal.causely.app/integrations) page
and check for any errors for the telemetry sources you have configured.

Errors in the integrations page will prevent Causely from discovering entities and connections in your environment. Follow the [troubleshooting steps](/telemetry-sources/troubleshooting) to resolve the errors.

  ## Connect Causely to AI Agents

Give your agents access to Causely's causal reasoning via the MCP server. Any MCP-compatible agent or assistant including Claude Code, Cursor, VS Code, HolmesGPT, or your own custom agent, can query root causes, service health, dependency maps, and reliability reports directly.

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Claude

    }
    description='Query root causes, service health, and dependency maps directly from Claude Code or Claude Desktop via the Causely MCP server.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Cursor

    }
    description='Investigate incidents and check service health without leaving your editor using the Causely MCP integration.'
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         Codex

    }
    description="Connect OpenAI's coding agent to Causely's causal reasoning via MCP for system-aware reliability workflows."
  />

  <GlowCard
    variant='violet'
    to='/agent-integration'
    title={

         HolmesGPT

    }
    description='Pre-built incident investigation agent with Causely MCP configured as its causal reasoning layer.'
  />

Visit the [agent integration](/agent-integration) page to get started.

:::tip Other Platforms Supported

While this quickstart guide focuses on Kubernetes, Causely also supports:

- **Container Orchestration**: [Nomad](/installation/nomad/), Docker, ECS
- **GitOps**: [Argo CD](/installation/argocd/), [Flux](/installation/flux/)
- **Virtual Machines**: Direct installation on VMs

For detailed installation instructions for these platforms, visit the [Installation Overview](/installation) page.

:::