Cognite
Use when building data integration pipelines, querying industrial data, deploying data models, managing access control, or developing applications that connect to industrial assets, time series, events, and files. Reach for this skill when working with REST APIs, SDKs (Python/JavaScript), data modeling, extractors, transformations, or infrastructure-as-code deployments. Use for **Cognite Flows** custom web apps hosted in CDF (React, `@cognite/cli`, Aura design-system UI with `@cognite/aura`, app hosting, local dev with Vite, deploy, and certification). Core data modelling (CDM)—use when working with CogniteAsset, CogniteTimeSeries, CogniteFile—the CDM concepts for assets, time series, and files. Reach for this skill when building asset hierarchies, populating time series, creating and linking files, or when searching for "Asset" in the API reference (CDM assets are in the Instances API. The legacy /assets endpoint is deprecated as of 2026-10-15 and retires on December 31, 2027).
How do I install this agent skill?
npx skills add https://docs.cognite.com --skill cogniteIs this agent skill safe to install?
No partner audit is available yet. Read the source before installing.
What does this agent skill do?
Cognite Data Fusion (CDF) skill
Product summary
Cognite Data Fusion is an industrial data platform that ingests, models, and exposes data from operational technology (OT) and information technology (IT) systems. Agents use CDF to build data pipelines (extract → transform → contextualize), define industrial knowledge graphs via data modeling, query resources via REST API or SDKs, and deploy configurations using the Cognite Toolkit. Cognite Flows adds a path to build and host custom React applications inside CDF (templates, CDF auth, AI-oriented skills, deploy); custom app UI uses the Aura design system (@cognite/aura). Key entry points: REST API at https://{cluster}.cognitedata.com/api/v1, Python SDK (cognite-sdk), JavaScript SDK (@cognite/sdk), the Cognite Toolkit CLI (cdf), and Flows via @cognite/cli apps. Primary docs: docs.cognite.com
API reference versioning
When linking to conceptual API reference pages (resource overviews, rate limits, introduction), use the versioned URL path that matches the calendar API version you mean. The published docs default to 20230101 unless the user or context specifies another calendar version (for example beta or alpha).
| Concept | Details |
|---|---|
| Default calendar version in URLs | 20230101 — use paths like /api-reference/concepts/20230101/<page> (for example /api-reference/concepts/20230101/api-description). |
| Runtime API behavior | Clients select behavior with the Cdf-Version HTTP header (YYYYMMDD, optional -beta / -alpha suffix). That is independent of which docs path you cite. |
| Policy | Deprecation, compatibility rules, and header semantics are documented in API versions. |
If the user is browsing a different API spec version in the API reference UI, prefer links under the same calendar segment (for example 20230101-beta or 20230101-alpha) when those stub pages exist in the repo.
When to use
Reach for this skill when:
- Integrating data: Setting up extractors (OPC UA, PI, SAP, databases) to stream data into CDF, configuring extraction pipelines, or monitoring data ingestion
- Modeling data: Designing data models with spaces, containers, views, and instances; querying graphs with GraphQL or REST; managing access via spaces
- Working with Assets in CDM: Creating or updating CogniteAsset hierarchies, populating assets via transformations, querying assets in CDF Search (shown as "Asset")
- Working with Assets (legacy): The
/assetsAPI and the other asset-centric services are deprecated as of 2026-10-15 and retire on December 31, 2027. Upgrade existing applications with the migration plugin. - Querying resources: Retrieving assets, time series, events, files, or sequences; using external IDs for lookups; filtering with advanced query language (AQL)
- Deploying infrastructure: Using the Cognite Toolkit to manage CDF projects as code, setting up CI/CD pipelines, or deploying modules
- Building applications: Authenticating with OAuth 2.0/OIDC, using Python/JavaScript SDKs to read/write data, or calling REST endpoints
- Building Flows custom apps: Creating React apps with
@cognite/cli, using Aura components and tokens, running them locally (Vite), deploying to CDF app hosting, or meeting builder certification and quality guidelines for customer environments - Managing access: Configuring OIDC providers, creating groups, assigning capabilities, or controlling access to spaces and data sets
- Automating workflows: Setting up data workflows with tasks and triggers, transforming data, or orchestrating multi-step processes
Core data modeling vs. legacy
The Cognite Data Fusion (CDF) platform supports two modes:
| Mode | Use case | Key concepts | API |
|---|---|---|---|
| Core data modeling (CDM) | New projects, knowledge graphs | CogniteAsset, CogniteTimeSeries, CogniteFile | Instances API, GraphQL |
| Legacy | Deprecated. Retires 2027-12-31. | Assets, Time series, Events, Files | /assets, /timeseries, /events, /files |
For new development, use core data modeling.
Asset-centric services are deprecated as of 2026-10-15 and retire on December 31, 2027. That includes the Assets, Events, Sequences, Relationships, Labels, Data sets, Annotations, and Geospatial APIs, plus asset-centric time series and file metadata. Data point reads and writes stay on the Time series API, and file content upload and download stay on the Files API. Both use instanceId. On the Engineering diagrams detect and convert endpoints (/context/diagram/detect and /context/diagram/convert), reference files with fileInstanceId, pass entities from your data model, and store results in the core data model. Those endpoints stay available for files in the core data model. The asset-centric OData service is deprecated for assets, events, sequences, and asset-centric file and time series metadata. Move those queries to the data modeling OData service. RAW stays available. Upgrade existing projects with the migration plugin. Dates and the full list are in Deprecated and retired features. Data modeling status describes how DATA_MODELING_ONLY and HYBRID projects behave during the upgrade.
Quick reference
Core resource types (core data modeling)
| Resource | CDM concept | Purpose | API / SDK |
|---|---|---|---|
| Assets | CogniteAsset | Hierarchical entities; shown as "Asset" in CDF Search | Instances API / data_modeling.instances |
| Time series | CogniteTimeSeries | Ordered data points over time | Instances API + Time Series API (data points) |
| Files | CogniteFile | Documents, diagrams, images | Instances API + File content API (upload) |
Legacy resource types
| Resource | Legacy API | Use when |
|---|---|---|
| Assets | /assets | Deprecated. Retires 2027-12-31. Use CogniteAsset. |
| Time series | /timeseries | Asset-centric metadata is deprecated. Data points stay on this API with instanceId. |
| Events | /events | Deprecated. Retires 2027-12-31. Use records or CogniteActivity. |
| Files | /files | Asset-centric metadata is deprecated. File content stays on this API with instanceId. |
Sequences, relationships, labels, data sets, annotations, and geospatial follow the same deprecation and retirement dates. On Engineering diagrams detect and convert, reference files with fileInstanceId and store results in the core data model. For OData, use the data modeling OData service for assets, events, sequences, and asset-centric file and time series metadata. RAW stays available on the asset-centric OData service.
Other resource types
| Resource | Purpose | Key field |
|---|---|---|
| RAW | Unstructured staging data | dbName, tableName |
| Data models | Graphs with spaces, containers, views | space, externalId |
Cognite Flows (custom web apps in CDF)
- Overview — Building Flows custom applications: when to use Flows versus other surfaces (for example Streamlit or Cognite Functions).
- First app — Get started with Flows custom apps: Node,
@cognite/cli, create a project, run in CDF. - UI — Aura, Install, Primitives: design system for Flows custom app UI (
@cognite/aura). - Concepts — Flows features, App lifecycle: auth, Vite, skills, spec-driven workflow. For capabilities, see Assign capabilities.
- Ship — Run locally, Deploy: dev server and publishing to CDF.
- Certification — Builder certification, Quality guidelines: customer production requirements.
- APIs in apps — Flows Auth API, Vite plugin API:
connectToHostAppand local tooling.
Common developer goals
| Goal | CDM approach | Documentation |
|---|---|---|
| Build an asset hierarchy | Create CogniteAsset instances with parent via Instances API | Building an asset hierarchy |
| Create and populate time series | Create CogniteTimeSeries; use Time Series API for data points | Integrate time series |
| Create and link files | Create CogniteFile instances; use File content API for upload | Integrate files |
| Query assets | Search/list CogniteAsset via Instances API or GraphQL | Core data model, Instances |
| Link time series to assets | Set assets relation on CogniteTimeSeries | Integrate time series |
| Link files to assets | Set assets relation on CogniteFile | Integrate files |
Authentication patterns
| Scenario | Method | Use case |
|---|---|---|
| Server-side scripts | API key or client credentials | Extractors, scheduled jobs |
| Web applications | OAuth 2.0 bearer token | Frontend apps, user sessions |
| Python SDK | OIDC with Entra ID | Interactive scripts, Jupyter |
| Cognite Toolkit | Service principal + client secret | CI/CD, automated deployments |
Cognite Toolkit workflow
cdf modules init # Initialize project structure
cdf build --env=dev # Build artifacts from YAML configs
cdf deploy --dry-run --env=dev # Validate before deploying
cdf deploy --env=dev # Deploy to CDF project
Configuration files
cdf.toml— Global CLI settings (organization, environment, plugins)config.[env].yaml— Per-environment project settings and module selectionmodules/— Resource directories (data_modeling/, raw/, access/, etc.)*.yaml— Resource configs (e.g.,my.space.yaml,my.container.yaml)
Common API endpoints
The legacy column is deprecated and retires on December 31, 2027. Time series data points and file content remain on those APIs and use instanceId. Engineering diagrams detect and convert stay available. Reference files with fileInstanceId. For OData, use the data modeling OData service. RAW stays available on the asset-centric OData service.
| Operation | CDM endpoint | Legacy endpoint |
|---|---|---|
| Create/update assets | POST /datamodels/instances/query (Instances API) | POST /assets |
| Create/update time series | Instances API + POST /timeseries/data (data points) | POST /timeseries |
| Create/update files | Instances API + POST /files/uploadlink | POST /files |
| List/query assets | Instances API, GraphQL | GET /assets, POST /assets/list |
| Query data model | POST /graphql | — |
Decision guidance
When to use REST API vs SDK
| Condition | Use REST API | Use SDK |
|---|---|---|
| Simple one-off requests | ✓ | |
| Batch operations, high throughput | ✓ | |
| Complex data transformations | ✓ | |
| Scripting/automation | ✓ | |
| Direct HTTP integration | ✓ |
When to use RAW vs data modeling
| Scenario | RAW | Data modeling |
|---|---|---|
| Staging raw source data | ✓ | |
| Temporary transformation storage | ✓ | |
| Structured industrial graphs | ✓ | |
| Long-term queryable data | ✓ | |
| Access control by space | ✓ |
When to use external ID vs internal ID
| Use case | External ID | Internal ID |
|---|---|---|
| Linking to source systems | ✓ | |
| Avoiding duplicates on insert | ✓ | |
| Human-readable lookups | ✓ | |
| Performance-critical reads | ✓ | |
| Batch operations | ✓ |
Query approach: CRUD vs advanced query
| Need | CRUD endpoints | Advanced query (AQL) |
|---|---|---|
| Fast, immediate consistency | ✓ | |
| Batch read/write operations | ✓ | |
| Complex filtering on metadata | ✓ | |
| Human exploration/analysis | ✓ | |
| Large-scale synchronization | ✓ |
Workflow
1. Set up authentication and project access
- Identify the authentication method (API key, OAuth 2.0, service principal)
- For Cognite Toolkit: configure
cdf.tomlwith organization and environment - For SDKs: set up OIDC provider (Entra ID or Amazon Cognito) and obtain credentials
- Test connectivity:
cdf statusorclient = CogniteClient()in Python
2. Understand your data model
- Identify source systems and their data types (time series, events, assets)
- Map external IDs from source systems to CDF resources
- Decide: will you use RAW for staging, or ingest directly into data models?
- If using data modeling: design spaces, containers, and views for your domain
3. Extract and stage data
- Choose an extractor (OPC UA, PI, SAP, database, REST, file, etc.)
- Configure the extractor with source credentials and CDF connection
- Set up an extraction pipeline to monitor ingestion
- Verify data arrives in RAW or target data model
4. Transform and contextualize
- Write SQL transformations to reshape RAW data into CDF resource types
- Use entity matching to link entities across source systems
- Build relationships between assets, time series, and events
- Assign external IDs consistently across all resources
5. Query and expose data
- Use REST API or SDK to retrieve resources by external ID or filter
- For complex queries: use GraphQL on data models or advanced query language (AQL)
- Implement pagination for large result sets (max 10,000 per request)
- Cache results where appropriate to reduce API calls
6. Deploy with infrastructure-as-code
- Define all resources (spaces, containers, views, access groups) in YAML
- Organize configs in modules under
modules/directory - Use
cdf buildto validate and generate artifacts - Use
cdf deploy --dry-runto preview changes before applying - Commit configs to version control and integrate with CI/CD (GitHub Actions, Azure DevOps, GitLab)
Common gotchas
- Asset search discovery: Searching for "Asset" in the API reference surfaces legacy
/assetsendpoints. For Core Data Modeling, use the Instances API with CogniteAsset—see Core data model and Building an asset hierarchy. - External ID uniqueness: External IDs are unique per resource type, not globally. An asset and time series can both have
externalId=123. Enforce this in your source system mapping. - Search vs CRUD consistency: Advanced query (AQL) is eventually consistent and slower than CRUD endpoints. Don't use it for large-scale batch synchronization; use
/byidsor/listinstead. - Pagination limits: Max 10,000 items per page. For data modeling queries, pagination only works at the top level; nested results cannot be paginated.
- Data modeling access control: Access is scoped to spaces, not data sets. Users need
dataModelsAcl.READto the space anddataModelInstancesAcl.READ/WRITEto instances. - Extraction pipeline monitoring: Create extraction pipelines to track ingestion health. Without them, you won't see run history or failure notifications.
- Toolkit module ordering: Spaces must be created before containers, containers before views, and views before data models. Use numbered prefixes (e.g.,
01_space.yaml,02_container.yaml) if dependencies exist within the same type. - Token expiration: OAuth 2.0 tokens expire. SDKs handle refresh automatically, but custom HTTP clients must implement token refresh logic.
- Rate limiting: CDF enforces throttling on parallel requests. Default: 20 parallel time series operations, 10 parallel data point operations. Respect these limits or requests will be queued.
- Asset-centric deprecation: Assets, events, sequences, relationships, labels, data sets, annotations, geospatial, and asset-centric time series and file metadata are deprecated as of 2026-10-15 and retire on December 31, 2027. Use core data modeling for new work. Data point and file content operations stay on
/timeseriesand/fileswithinstanceId. On Engineering diagrams detect and convert, usefileInstanceIdand store results in the core data model. For OData, use the data modeling OData service. RAW stays available on the asset-centric OData service. See Deprecated and retired features. - Deprecated API versions: API v0.5, v0.6 are removed. Always use the latest API version (v1).
- Missing capabilities: Users need specific capabilities (e.g.,
timeseries:read,assets:write) to perform operations. Check access errors against the capabilities reference.
Verification checklist
Before submitting work:
- Authentication works: Test with
cdf status(Toolkit) orclient.data_modeling.instances.list()(SDK).client.assets.list()applies only to asset-centric maintenance until December 31, 2027. - External IDs are set: All resources have unique, consistent external IDs from source systems
- Data flows end-to-end: Verify data appears in CDF (check extraction pipeline runs, query a sample asset/time series)
- Access is configured: Test that intended users/groups can read/write resources; check space and capability assignments
- Queries are efficient: For data modeling, run with
profile: trueto check debug notices; avoid full table scans - Pagination is handled: If retrieving >10,000 items, implement cursor-based pagination
- Dry-run passes: Run
cdf deploy --dry-runand review changes before applying - CI/CD is integrated: Toolkit configs are in version control and CI/CD pipeline validates/deploys on merge
- Monitoring is in place: Extraction pipelines, data workflows, and functions have alerts configured
- Documentation is updated: Record external ID mappings, data model schema, and access policies
Resources
Core data modeling
- Core data model reference: CogniteAsset, CogniteTimeSeries, CogniteFile
- Build asset hierarchy: dm_cdm_build_asset_hierarchy
- Integrate time series: dm_integrate_with_time_series
- Integrate files: dm_integrate_files
- Instances API: Overview
- Asset-centric deprecation: Deprecated and retired features — Migration plugin
General
- Cognite Flows: Overview — Get started — Deploy — Flows features — Aura
- Comprehensive navigation: docs.cognite.com/llms.txt — Mintlify-generated index; follow
/_llms/links recursively until you reach.mdpage URLs - REST API reference: /api-reference/concepts/20230101/api-description
- Python SDK: cognite-sdk-python.readthedocs-hosted.com
- JavaScript SDK: docs.cognite.com/dev/sdks/js
- Cognite Toolkit: docs.cognite.com/cdf/deploy/cdf_toolkit
- Data modeling: docs.cognite.com/cdf/dm
- Data integration: docs.cognite.com/cdf/integration
- Access control: docs.cognite.com/cdf/access
For additional documentation and navigation, see: docs.cognite.com/llms.txt
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/docs.cognite.com/cognite">View Cognite on skillZs</a>