> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cognite.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Foundation Demo DP reference

> Deploy a complete end-to-end CDF demo environment in one pass — extraction pipelines, an enterprise data model, contextualization, search, and quality monitoring with Open Industrial Data.

The **Foundation Demo DP** (`dp:quickstart`) is an integrated bundle of deployment packs and modules that stands up a complete, end-to-end CDF environment in a single deployment: source ingestion, an enterprise data model, entity matching, file annotation, contextualization quality monitoring, and synthetic test data. It is the fastest way to get a fully functional CDF project running with real workflows — from raw source data through contextualized assets — without assembling individual packs manually.

<Note>
  The Foundation Demo DP is a **fixed bundle** (`canCherryPick = false`) — modifying or cherry-picking individual modules within the pack is not supported. In the Toolkit menu it appears as **Foundation Deployment Pack Demo**. If you need a customized setup, add the constituent modules individually with `cdf modules add`. For a production baseline rather than a demo, use the [Foundation](/cdf/deploy/cdf_toolkit/references/packages/foundation) deployment pack.
</Note>

## Who it's for

**Target personas:**

* **Data engineers** — deploy and configure the demo bundle end-to-end.
* **Solution architects** — evaluate CDF capabilities before committing to a project-specific model.
* **Field engineers** — showcase CDF capabilities in a matter of minutes with the Open Industrial Data.

**Use this pack when:**

* You are starting a new CDF project and want a complete, integrated pipeline — ingestion, data model, contextualization, and monitoring — deployed in one step.
* You want to evaluate or demonstrate CDF's full stack (entity matching, P\&ID annotation, search, quality reporting) using included synthetic data without live integrations.
* You need a standardized baseline that your team can then customize module by module.
* You want to validate CDF capabilities before committing to a project-specific data model.

**When not to use this pack:**

* If you only need one specific capability (for example, entity matching or P\&ID annotation) — use the individual deployment packs instead to avoid deploying unused modules.
* If you are building a governed production environment rather than a demo — use the [Foundation](/cdf/deploy/cdf_toolkit/references/packages/foundation) deployment pack.

## What's included

The bundle deploys 13 modules across four layers.

### Foundation and data model

| Module             | Description                                                                                                   | Optional? |
| ------------------ | ------------------------------------------------------------------------------------------------------------- | --------- |
| `cdf_common`       | Shared spaces, datasets, RAW databases, and relation-writer runtime resources used by all downstream modules. | No        |
| `cdf_ingestion`    | Orchestration workflow that runs staged pipelines — data population first, then contextualization.            | No        |
| `cdf_search`       | Location and search structures for Industrial Tools experiences.                                              | No        |
| `qs_enterprise_dm` | The Quickstart enterprise data model — containers, views, and spaces.                                         | No        |

### Source systems and synthetic data

| Module           | Description                                                                                                | Optional? |
| ---------------- | ---------------------------------------------------------------------------------------------------------- | --------- |
| `cdf_sap_assets` | Ingests and transforms SAP functional locations and equipment. Includes synthetic SAP asset data.          | No        |
| `cdf_sap_events` | Ingests maintenance notifications, orders, and operations. Includes synthetic SAP events data.             | No        |
| `cdf_pi`         | Creates time series entities and metadata from PI inputs. Includes synthetic PI time series data.          | No        |
| `cdf_sharepoint` | Loads files for annotation, including the P\&IDs used in testing. Includes synthetic SharePoint file data. | No        |
| `cdf_oid_sync`   | Replays time-shifted Open Industrial Data to simulate continuous updates.                                  | No        |

### Contextualization

| Module                | Description                                                                                                                                                       | Optional? |
| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- |
| `cdf_connection_sql`  | Links entities using deterministic SQL and tag-based mapping logic.                                                                                               | No        |
| `cdf_entity_matching` | Matches time series and assets using rule-based and ML-assisted methods. See [CDF Entity Matching](/cdf/deploy/cdf_toolkit/references/packages/entity_matching).  | No        |
| `cdf_file_annotation` | Runs prepare, launch, finalize, and promote steps for P\&ID file annotations. See [P\&ID Annotation](/cdf/deploy/cdf_toolkit/references/packages/pid_annotation). | No        |

### Monitoring

| Module           | Description                                                             | Optional? |
| ---------------- | ----------------------------------------------------------------------- | --------- |
| `report_quality` | Computes contextualization KPIs and stores rates for monitoring trends. | No        |

## Prerequisites

Verify all of the following before you start:

* Cognite Toolkit version **0.8 or later** is installed. See [Setting up](/cdf/deploy/cdf_toolkit/guides/setup).

* A `cdf.toml` file exists in your project root. If it is missing, run `cdf modules init .` and select **Create toml file (required)**.

* The data plugin is enabled in `cdf.toml` — required for the `cdf data upload` steps:

  ```toml theme={"languages":{"custom":["/_languages/kuiper.json","../_languages/kuiper.json"]}}
  [plugins]
  data = true
  ```

* Authentication is configured and verified — run `cdf auth init` and `cdf auth verify`. See [Authentication and authorization](/cdf/deploy/cdf_toolkit/guides/auth).

* The following values are available for your `.env` file:
  * `GROUP_SOURCE_ID` — the Object ID of your IdP group.
  * `OPEN_ID_CLIENT_SECRET` — generated from the Open Industrial Data Hub page with **Create client secret**.

## Install and deploy

Because the Foundation Demo DP is a fixed bundle, deploying into a clean project is recommended.

<Tabs>
  <Tab title="Start a new project (recommended)">
    1. In a clean directory, initialize and select the bundle:

       ```sh theme={"languages":{"custom":["/_languages/kuiper.json","../_languages/kuiper.json"]}}
       cdf modules init . --clean
       ```

           <Warning>
             `--clean` overwrites existing module folders in the current directory. Use a fresh directory or commit your changes first.
           </Warning>

    2. From the interactive module list, use **Space** to select **Foundation Deployment Pack Demo**, then press **Enter** to confirm.
  </Tab>

  <Tab title="Add to an existing project">
    Run `cdf modules add` and select **Foundation Deployment Pack Demo** from the interactive list.

    <Warning>
      The Foundation Demo DP is a fixed bundle and may conflict with modules you have already deployed. Review your existing module structure and commit local changes before proceeding.
    </Warning>
  </Tab>
</Tabs>

Then configure the project before building:

1. Set your CDF project name in `config.<env>.yaml`, and add `GROUP_SOURCE_ID` and `OPEN_ID_CLIENT_SECRET` to your `.env` file (do not hardcode secrets in config files).

2. Under `cdf_entity_matching`, update the view configuration to match the Quickstart data model:

   | Variable                                            | Change from         | Change to               |
   | --------------------------------------------------- | ------------------- | ----------------------- |
   | `targetViewFilterValues`                            | `root:WMT`          | `root:ast_VAL`          |
   | `targetViewSearchProperty`                          | `name`              | `aliases`               |
   | `AssetViewExternalId` / `targetViewExternalId`      | `YourOrgAsset`      | `Asset`                 |
   | `TimeSeriesViewExternalId` / `entityViewExternalId` | `YourOrgTimeSeries` | `Enterprise_TimeSeries` |

3. Under `cdf_file_annotation`, set `ApplicationOwner` to the owner email address(es).

4. Review all cron expressions — placeholder values may be set to February 29 and must be changed to valid recurring dates.

5. Enable **FILE\_ANNOTATION mode** in the SAP asset transformation. In `modules/sourcesystem/cdf_sap_assets/transformations/population/asset.Transformation.sql`, comment out the **COMMON MODE** block and uncomment the **FILE\_ANNOTATION MODE** block. This sets asset external IDs as `ast_<id>`, creates the `ast_VAL` root node, and populates the aliases and tags that diagram detection needs.

Then build and deploy:

<Steps>
  <Step title="Build deployment artifacts">
    ```sh theme={"languages":{"custom":["/_languages/kuiper.json","../_languages/kuiper.json"]}}
    cdf build
    ```

    The Toolkit substitutes template variables and writes artifacts to the `build/` directory. If you need to change the project name or any variables marked `<change_me>`, edit `config.<env>.yaml` first — see [Configure, build, and deploy modules](/cdf/deploy/cdf_toolkit/guides/usage).
  </Step>

  <Step title="Dry-run the deployment">
    ```sh theme={"languages":{"custom":["/_languages/kuiper.json","../_languages/kuiper.json"]}}
    cdf deploy --dry-run
    ```

    Inspect the output and confirm that configurations look correct before deploying.
  </Step>

  <Step title="Deploy to CDF">
    ```sh theme={"languages":{"custom":["/_languages/kuiper.json","../_languages/kuiper.json"]}}
    cdf deploy
    ```

    The Toolkit deploys only configurations that have changed since the last run.
  </Step>

  <Step title="Set up CI/CD (optional)">
    For governed production deployments, automate build, dry-run, and deploy in a pipeline. See [Set up CI/CD pipelines](/cdf/deploy/cdf_toolkit/guides/cicd/index).
  </Step>
</Steps>

<Note>
  A warning about non-resource directories such as `upload_data` in `cdf_pi` is expected and can be ignored.
</Note>

After deployment, upload the synthetic test data for the source and contextualization modules:

```sh theme={"languages":{"custom":["/_languages/kuiper.json","../_languages/kuiper.json"]}}
cdf data upload dir modules/sourcesystem/cdf_pi/upload_data
cdf data upload dir modules/sourcesystem/cdf_sap_assets/upload_data
cdf data upload dir modules/sourcesystem/cdf_sap_events/upload_data
cdf data upload dir modules/sourcesystem/cdf_sharepoint/upload_data
cdf data upload dir modules/contextualization/cdf_entity_matching/upload_data
cdf data upload dir modules/contextualization/cdf_file_annotation/upload_data
```

<Note>
  If your modules directory is under an organization directory, prepend that directory name to each path. To skip project-name verification in test environments, add `--skip-verify-cdf-project` to each upload command.
</Note>

Finally, in the CDF Data Workflows UI, trigger the workflows in order — wait for each to finish before starting the next:

1. **ingestion** — populates the data model and creates baseline relationships.
2. **cdf\_file\_annotation** — annotates the uploaded P\&ID files and links them to assets.
3. **EntityMatching** — runs metadata enrichment and entity matching.

## Verify the deployment

After deployment and workflow execution, confirm success with these checks:

1. The `cdf deploy` command finishes without errors and all modules deploy successfully.
2. All `cdf data upload` commands finish without errors — in **Integrate > Staging (RAW)**, confirm the tables from each module's `upload_data/` are present.
3. In **Integrate > Data Workflows**, confirm the three workflows (**ingestion**, **cdf\_file\_annotation**, **EntityMatching**) completed without errors.
4. Open **Industrial Tools > Search > Files** and confirm that uploaded P\&IDs have linked assets — annotations are applied.
5. In **Build Solutions > Functions**, review the logs for the entity matching function and confirm time series were processed without errors.
6. In **Data Modeling > Data Models**, confirm the Quickstart enterprise data model is deployed with its spaces, containers, and views.
7. Run the quality report workflow, then confirm the contextualization-rate report table is populated in the quality reports RAW database.

The deployment is successful when all three workflows complete, annotations and matches appear, and the quality report produces KPI output.

## Configuration reference

All parameters are set in `config.<env>.yaml` at the project root. Sensitive values (`GROUP_SOURCE_ID`, client IDs and secrets) must be set in your `.env` file, not hardcoded.

Because this is a fixed demo bundle, all of the following must be set or updated before deploying:

| Parameter                                           | Module                | Description                                                                                           |
| --------------------------------------------------- | --------------------- | ----------------------------------------------------------------------------------------------------- |
| CDF project name                                    | All                   | Your CDF project external ID for the target environment.                                              |
| `GROUP_SOURCE_ID`                                   | All                   | Object ID of your IdP group (`.env`). Used for data model updates and transformation runs.            |
| `OPEN_ID_CLIENT_SECRET`                             | `cdf_oid_sync`        | Client secret for the Open Industrial Data application (`.env`).                                      |
| `targetViewFilterValues`                            | `cdf_entity_matching` | Filter value for the target asset view. Update `root:WMT` → `root:ast_VAL`.                           |
| `targetViewSearchProperty`                          | `cdf_entity_matching` | Search property on the target view. Update `name` → `aliases`.                                        |
| `AssetViewExternalId` / `targetViewExternalId`      | `cdf_entity_matching` | External ID of the asset view. Update `YourOrgAsset` → `Asset`.                                       |
| `TimeSeriesViewExternalId` / `entityViewExternalId` | `cdf_entity_matching` | External ID of the time series view. Update `YourOrgTimeSeries` → `Enterprise_TimeSeries`.            |
| `ApplicationOwner`                                  | `cdf_file_annotation` | Email address(es) of the application owner for the file annotation pipeline.                          |
| Cron expressions                                    | All scheduled modules | Placeholder cron values may be set to February 29 — update to valid recurring dates before deploying. |

## Architecture

The Foundation Demo DP is a fixed bundle of Cognite Toolkit modules across four layers. The `cdf_ingestion` workflow enforces execution order — data population runs before contextualization — so each layer has the data it needs when it runs.

```text theme={"languages":{"custom":["/_languages/kuiper.json","../_languages/kuiper.json"]}}
modules/
├── common/
│   ├── cdf_common/        ← shared spaces, datasets, RAW
│   ├── cdf_ingestion/     ← staged orchestration workflow
│   └── cdf_search/        ← search + location structures
├── sourcesystem/
│   ├── cdf_pi/            ← PI time series + synthetic data
│   ├── cdf_sap_assets/    ← SAP assets + synthetic data
│   ├── cdf_sap_events/    ← SAP events + synthetic data
│   ├── cdf_sharepoint/    ← files + synthetic P&IDs
│   └── cdf_oid_sync/      ← Open Industrial Data sync
├── contextualization/
│   ├── cdf_connection_sql/  ← deterministic SQL linking
│   ├── cdf_entity_matching/ ← rule-based + ML matching
│   └── cdf_file_annotation/ ← P&ID annotation pipeline
├── dashboards/
│   └── report_quality/   ← contextualization KPI monitoring
└── datamodels/
    └── qs_enterprise_dm/ ← Quickstart enterprise data model
```

### Pipeline execution order

```mermaid theme={"languages":{"custom":["/_languages/kuiper.json","../_languages/kuiper.json"]}}
flowchart TD
    subgraph Sources["Source systems (synthetic data)"]
        SAP["cdf_sap_assets · cdf_sap_events"]
        PI["cdf_pi"]
        SP["cdf_sharepoint"]
        OID["cdf_oid_sync"]
    end

    Sources --> Ingest["ingestion workflow<br/>populate qs_enterprise_dm"]
    Ingest --> Anno["cdf_file_annotation workflow<br/>prepare → launch → finalize → promote"]
    Ingest --> Match["EntityMatching workflow<br/>metadata enrichment + matching"]
    Ingest --> SQL["cdf_connection_sql<br/>deterministic linking"]

    Anno --> DM[("Quickstart enterprise data model")]
    Match --> DM
    SQL --> DM
    DM --> Search["cdf_search · Industrial Tools"]
    DM --> Quality["report_quality<br/>contextualization KPIs"]
```

### FILE\_ANNOTATION mode

For P\&ID annotation to work, the SAP asset transformation must use FILE\_ANNOTATION mode rather than COMMON mode. This mode sets asset external IDs as `ast_<id>`, creates the `ast_VAL` root node, and populates the aliases and tags the file annotation pipeline uses for diagram detection. It is a manual SQL edit in `asset.Transformation.sql` before deployment.

## Troubleshooting

| Symptom                                                   | Likely cause                                                                                                   | Resolution                                                                                                                                                |
| --------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Module files overwritten unexpectedly                     | Ran `cdf modules init . --clean` in a directory with existing work.                                            | Use a clean directory, or commit existing work first. Use `cdf modules add` to add modules to an existing project without overwriting.                    |
| `cdf data upload` fails with "data plugin not enabled"    | `[plugins] data = true` is missing from `cdf.toml`.                                                            | Add `data = true` under `[plugins]` in `cdf.toml` and retry.                                                                                              |
| `cdf data upload` fails with a project verification error | The project name in the upload manifest does not match the configured CDF project.                             | Add `--skip-verify-cdf-project` for test environments, or align the project name in `Manifest.yaml` with your CDF project.                                |
| File annotation finds no matches                          | FILE\_ANNOTATION mode was not enabled, so the `ast_VAL` root and aliases are missing.                          | Enable FILE\_ANNOTATION mode in `asset.Transformation.sql`, redeploy, and re-run the ingestion and annotation workflows.                                  |
| Entity matching returns no results                        | View external IDs in `cdf_entity_matching` still use placeholder values (`YourOrgAsset`, `YourOrgTimeSeries`). | Update all entity matching view configuration values as listed in [Configuration reference](#configuration-reference).                                    |
| Workflow fails on the first run after deploy              | Synthetic data was not uploaded before triggering workflows, or an upload failed.                              | Verify all `cdf data upload` commands completed and the expected tables are visible in **Integrate > Staging (RAW)** before triggering workflows.         |
| Scheduled workflows fail to trigger                       | Cron expressions are set to an invalid date (for example, February 29 in a non-leap year).                     | Update all cron expressions in the config to valid recurring dates before deploying.                                                                      |
| `cdf deploy` fails with "Insufficient permissions"        | Toolkit service account is missing capabilities required by one or more modules.                               | Add capabilities for Functions, Workflows, Transformations, RAW, Data Sets, Data Modeling, and Extraction Pipelines to the CDF group used by the Toolkit. |

For issues not covered here, contact Cognite support.

## Support

| Field                  | Details                                                                     |
| ---------------------- | --------------------------------------------------------------------------- |
| Team                   | Cognite Value Delivery Team                                                 |
| Documentation          | [Cognite product documentation](/)                                          |
| Questions and feedback | [Deployment Packs group on Cognite Hub](https://hub.cognite.com/groups/578) |
| Version                | 1.0.0                                                                       |
| Last updated           | 2026                                                                        |