# How to Integrate Understand Anything with Your CI/CD Pipeline

> Integrate Understand Anything into your CI/CD pipeline easily. Follow our guide to automatically generate versioned knowledge graphs as a standard build step. Enhance your workflow today.

- Repository: [Egonex/Understand-Anything](https://github.com/Egonex-AI/Understand-Anything)
- Tags: how-to-guide
- Published: 2026-06-25

---

**Run `pnpm exec understand --auto-update` as a standard build step in any CI system to generate a versioned knowledge graph artifact.**

**Understand Anything** is a multi-agent, LLM-augmented static analysis plugin from the [Egonex-AI/Understand-Anything](https://github.com/Egonex-AI/Understand-Anything) repository. Because it exposes a pure CLI interface, you can embed it into GitHub Actions, GitLab CI, Jenkins, or any other CI/CD system that executes shell commands. The tool analyzes your codebase using Tree-sitter, enriches the results with LLM-generated summaries, and outputs a JSON knowledge graph to [`.understand-anything/knowledge-graph.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.understand-anything/knowledge-graph.json).

## How Understand Anything Works in CI/CD

The integration follows a deterministic pipeline that fits naturally into standard build stages.

First, the **`understand`** CLI entry point triggers a series of agents defined in the plugin. The **project-scanner** agent (documented in [`understand-anything-plugin/agents/project-scanner.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/agents/project-scanner.md)) detects your repository structure and CI configuration files, while the **file-analyzer** agent (in [`understand-anything-plugin/agents/file-analyzer.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/agents/file-analyzer.md)) parses individual files using Tree-sitter to extract imports, functions, and classes.

Next, an LLM layer adds human-readable summaries, architectural tags, and business-domain annotations. The final output is a pure JSON knowledge graph written to [`.understand-anything/knowledge-graph.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.understand-anything/knowledge-graph.json). Because this file is machine-readable and text-based, you can version-control it, upload it as a pipeline artifact, or feed it into downstream automation jobs.

## GitHub Actions Integration

Add a dedicated workflow file to run the analysis after your build steps complete. The repository already includes a reference implementation in [`.github/workflows/ci.yml`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.github/workflows/ci.yml) that builds the core and skill packages before running tests.

Here is a minimal workflow that builds the plugin and archives the knowledge graph:

```yaml

# .github/workflows/understand.yml

name: Understand Anything
on:
  push:
    branches: [main, develop]

jobs:
  graph:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: pnpm/action-setup@v4
        with:
          version: 9
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: pnpm
      
      - name: Install dependencies
        run: pnpm install
      
      - name: Build core
        run: pnpm --filter @understand-anything/core build
      
      - name: Build skill
        run: pnpm --filter @understand-anything/skill build
      
      - name: Generate knowledge graph
        run: pnpm exec understand --auto-update
      
      - name: Archive graph
        run: tar -czf graph.tgz .understand-anything/knowledge-graph.json
      
      - uses: actions/upload-artifact@v4
        with:
          name: knowledge-graph
          path: graph.tgz

```

The `--auto-update` flag ensures the command is idempotent; it only re-analyzes files that changed since the last run, keeping additional CI time to a minimum.

## GitLab CI Integration

For GitLab pipelines, define stages for installation, building, and analysis. The JSON output can be declared as an artifact for subsequent jobs or downloads.

```yaml

# .gitlab-ci.yml

stages:
  - install
  - build
  - analyze

install:
  image: node:22
  script:
    - npm i -g pnpm
    - pnpm install

build:
  image: node:22
  script:
    - pnpm --filter @understand-anything/core build
    - pnpm --filter @understand-anything/skill build

analyze:
  image: node:22
  script:
    - pnpm exec understand --auto-update
  artifacts:
    paths:
      - .understand-anything/knowledge-graph.json
    expire_in: 1 week

```

## Jenkins Pipeline Integration

In a declarative Jenkins pipeline, add the analysis stage after building the plugin packages. Use the `archiveArtifacts` step to store the graph.

```groovy
pipeline {
    agent any
    stages {
        stage('Setup') {
            steps {
                sh 'npm i -g pnpm'
                sh 'pnpm install'
            }
        }
        stage('Build Plugin') {
            steps {
                sh 'pnpm --filter @understand-anything/core build'
                sh 'pnpm --filter @understand-anything/skill build'
            }
        }
        stage('Generate Graph') {
            steps {
                sh 'pnpm exec understand --auto-update'
                archiveArtifacts artifacts: '.understand-anything/knowledge-graph.json', fingerprint: true
            }
        }
    }
}

```

## Key Integration Points

When adding Understand Anything to existing pipelines, focus on these five stages:

- **Setup.** Run `pnpm install` to pull in `@understand-anything/core` and `@understand-anything/skill` packages. This is identical to standard Node dependency installation.

- **Build.** Compile the plugin runtime before executing analysis. Run `pnpm --filter @understand-anything/core build` and `pnpm --filter @understand-anything/skill build` to ensure the agents are ready.

- **Analysis.** Execute `pnpm exec understand --auto-update` to generate the knowledge graph. This command runs entirely offline after the initial setup.

- **Artifact Publishing.** Compress [`.understand-anything/knowledge-graph.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.understand-anything/knowledge-graph.json) and upload it using your CI's artifact storage (e.g., `actions/upload-artifact@v4` for GitHub Actions or `archiveArtifacts` for Jenkins).

- **Optional Commit.** If you want the graph version-controlled, add a step to commit the JSON file: `git add .understand-anything/knowledge-graph.json && git commit -m "Update knowledge graph"`. This is useful for onboarding documentation that stays in sync with the repository.

For local development parity, you can also install a post-commit hook. The repository provides a template in [`understand-anything-plugin/hooks/auto-update-prompt.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/hooks/auto-update-prompt.md) that runs `understand --auto-update` after every local commit.

## Summary

- **Understand Anything** runs as a CLI tool (`pnpm exec understand`) that fits into any CI system supporting Node.js.
- The pipeline uses Tree-sitter for deterministic parsing and LLMs for semantic enrichment, outputting to [`.understand-anything/knowledge-graph.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.understand-anything/knowledge-graph.json).
- Build the `@understand-anything/core` and `@understand-anything/skill` packages before running analysis.
- Use the `--auto-update` flag for incremental analysis that only processes changed files.
- Archive the JSON output as a pipeline artifact or commit it directly to version control for team access.

## Frequently Asked Questions

### What is the performance impact on CI build times?

The impact is minimal. The `--auto-update` flag enables incremental analysis, meaning the tool only re-parses files that changed since the last run. For medium-sized projects, this typically adds only a few seconds to the pipeline. The Tree-sitter parsing layer is deterministic and fast, while LLM enrichment happens selectively based on code changes.

### Can I use Understand Anything with CI systems other than GitHub Actions?

Yes. Because the tool is a standard CLI application distributed via PNPM, it works with any CI/CD platform that can execute shell commands, including GitLab CI, Jenkins, CircleCI, Azure DevOps, and Bitbucket Pipelines. The examples in the repository (found in [`.github/workflows/ci.yml`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.github/workflows/ci.yml) and [`understand-anything-plugin/agents/project-scanner.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/agents/project-scanner.md)) demonstrate detection of various CI config files including [`.gitlab-ci.yml`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.gitlab-ci.yml) and `Jenkinsfile`.

### Where is the knowledge graph stored and how can teams access it?

By default, the graph is written to [`.understand-anything/knowledge-graph.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/.understand-anything/knowledge-graph.json) in your repository. You can configure your CI pipeline to upload this file as a build artifact, store it in an internal artifact repository, or commit it back to the repository. The JSON format is self-contained and portable, making it easy to share with dashboards, documentation generators, or other downstream tools.

### How do I ensure the analysis results are reproducible across different CI runs?

The analysis is deterministic because the Tree-sitter parsing layer extracts static code structure identically on every run. To guarantee reproducibility, pin the `@understand-anything/core` and `@understand-anything/skill` package versions in your [`package.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/package.json) or lockfile. The test suite in [`understand-anything-plugin/packages/core/src/__tests__/parsers.test.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/packages/core/src/__tests__/parsers.test.ts) validates that CI-related parsers produce consistent output across environments.