skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
docs.cognite.com62 installs

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 cognite
view source ↗

Is 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).

ConceptDetails
Default calendar version in URLs20230101 — use paths like /api-reference/concepts/20230101/<page> (for example /api-reference/concepts/20230101/api-description).
Runtime API behaviorClients select behavior with the Cdf-Version HTTP header (YYYYMMDD, optional -beta / -alpha suffix). That is independent of which docs path you cite.
PolicyDeprecation, 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 /assets API 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:

ModeUse caseKey conceptsAPI
Core data modeling (CDM)New projects, knowledge graphsCogniteAsset, CogniteTimeSeries, CogniteFileInstances API, GraphQL
LegacyDeprecated. 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)

ResourceCDM conceptPurposeAPI / SDK
AssetsCogniteAssetHierarchical entities; shown as "Asset" in CDF SearchInstances API / data_modeling.instances
Time seriesCogniteTimeSeriesOrdered data points over timeInstances API + Time Series API (data points)
FilesCogniteFileDocuments, diagrams, imagesInstances API + File content API (upload)

Legacy resource types

ResourceLegacy APIUse when
Assets/assetsDeprecated. Retires 2027-12-31. Use CogniteAsset.
Time series/timeseriesAsset-centric metadata is deprecated. Data points stay on this API with instanceId.
Events/eventsDeprecated. Retires 2027-12-31. Use records or CogniteActivity.
Files/filesAsset-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

ResourcePurposeKey field
RAWUnstructured staging datadbName, tableName
Data modelsGraphs with spaces, containers, viewsspace, externalId

Cognite Flows (custom web apps in CDF)

Common developer goals

GoalCDM approachDocumentation
Build an asset hierarchyCreate CogniteAsset instances with parent via Instances APIBuilding an asset hierarchy
Create and populate time seriesCreate CogniteTimeSeries; use Time Series API for data pointsIntegrate time series
Create and link filesCreate CogniteFile instances; use File content API for uploadIntegrate files
Query assetsSearch/list CogniteAsset via Instances API or GraphQLCore data model, Instances
Link time series to assetsSet assets relation on CogniteTimeSeriesIntegrate time series
Link files to assetsSet assets relation on CogniteFileIntegrate files

Authentication patterns

ScenarioMethodUse case
Server-side scriptsAPI key or client credentialsExtractors, scheduled jobs
Web applicationsOAuth 2.0 bearer tokenFrontend apps, user sessions
Python SDKOIDC with Entra IDInteractive scripts, Jupyter
Cognite ToolkitService principal + client secretCI/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 selection
  • modules/ — 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.

OperationCDM endpointLegacy endpoint
Create/update assetsPOST /datamodels/instances/query (Instances API)POST /assets
Create/update time seriesInstances API + POST /timeseries/data (data points)POST /timeseries
Create/update filesInstances API + POST /files/uploadlinkPOST /files
List/query assetsInstances API, GraphQLGET /assets, POST /assets/list
Query data modelPOST /graphql—

Decision guidance

When to use REST API vs SDK

ConditionUse REST APIUse SDK
Simple one-off requests✓
Batch operations, high throughput✓
Complex data transformations✓
Scripting/automation✓
Direct HTTP integration✓

When to use RAW vs data modeling

ScenarioRAWData 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 caseExternal IDInternal ID
Linking to source systems✓
Avoiding duplicates on insert✓
Human-readable lookups✓
Performance-critical reads✓
Batch operations✓

Query approach: CRUD vs advanced query

NeedCRUD endpointsAdvanced 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.toml with organization and environment
  • For SDKs: set up OIDC provider (Entra ID or Amazon Cognito) and obtain credentials
  • Test connectivity: cdf status or client = 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 build to validate and generate artifacts
  • Use cdf deploy --dry-run to 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 /assets endpoints. 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 /byids or /list instead.
  • 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.READ to the space and dataModelInstancesAcl.READ/WRITE to 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 /timeseries and /files with instanceId. On Engineering diagrams detect and convert, use fileInstanceId and 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) or client.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: true to 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-run and 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

General


For additional documentation and navigation, see: docs.cognite.com/llms.txt

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>