Dataiku Headless

View saved version →

---
name: dataiku-headless
description: Use for Dataiku tasks including projects, flows, datasets, recipes, jobs, machine learning, agents, and Cobuild conversations. Choose the right reference guide, inspect state first, route project changes through Cobuild by default, and validate results after execution.
---

# Dataiku Headless

Use this for any Dataiku task. Choose the right reference guide first, inspect the current state before acting, route project changes through Cobuild by default, and validate by re-reading the resulting state.

## Shared Operating Rules

1. If the user asks to install, set up, connect, or repair Dataiku Headless, or its MCP tools are unavailable just after installation, read `../dataiku-headless-setup/SKILL.md`. Choose either local stdio or customer-managed HTTP setup and never enable both.
2. Ensure an instance is configured before any Dataiku work. In local stdio mode, if `get_current_instance` errors or `list_instances` is empty, run `configure_instance` first. In HTTP mode, use `list_instances` then `switch_instance`; the instance catalog is platform-managed. Keep the reported `dataiku_version` in context for version-sensitive requests. The required `instance_type` is configured metadata, not API verification or a guarantee of client support.
3. Discover project keys and object identifiers through tools; do not invent them.
4. Read before write. Inspect the current object, flow context, jobs, or run history before changing anything.
5. Treat the matching reference guide as the source of truth for object-specific concepts, inspection steps, and required references.
6. Route in-project asset creation and modification through `./references/cobuild.md` unless the matching guide documents a narrow direct exception.
7. Direct-write exceptions are allowed for operations that Cobuild cannot perform, especially bootstrap, cross-project, instance-level, or administrative actions. Treat them as narrow documented exceptions, not as the default mutation path.
8. Use visual recipes by default. A code recipe is appropriate only when the user explicitly requests a code-based transformation.
9. Preserve surrounding flow, storage, and operational context unless the user requests a change.
10. If MCP or Cobuild coverage is insufficient, stop and report the gap rather than falling back to raw Python, `dataikuapi`, or ad hoc REST calls. Attribute the gap to the Dataiku version only when that requirement is known; otherwise, do not guess.

## Default Workflow

1. Identify the target project and the user's main object of work.
2. Read the matching reference guide from the routing table below.
3. Follow that guide's inspection flow and read any references it explicitly requires.
4. If the task is read-only, answer from the inspected state.
5. If the task changes in-project assets, switch to `./references/cobuild.md` with grounded names, constraints, and context from the guide.
6. If the task is a documented direct-write exception, follow the matching guide's direct-write path instead of forcing it through Cobuild.
7. Keep the user's main object of work as the primary guide. Read supporting guides only when the primary guide tells you they are relevant.
8. For tasks that span multiple object types, keep one primary guide and read supporting guides for dependent objects or job/run follow-up.
9. Completion status is not enough. Validate by re-reading the changed object and using `./references/jobs.md` when execution may still be in progress.

## Guide Routing

| User intent | Guide to read next |
| --- | --- |
| Discover projects, inspect project metadata or variables, orient in a flow, or create a new project | `./references/projects.md` |
| Inspect or update project settings, including Flow display, pipelines, default code envs, project-level container execution defaults, or Cobuild project instructions | `./references/projects/settings.md` |
| Inspect the instance project-folder hierarchy or organize projects into project folders | `./references/project-folders.md` |
| Build, modify, or continue project-level work through Cobuild | `./references/cobuild.md` |
| Inspect datasets, schema, samples, or metrics; export a local CSV; or create an Uploaded Files dataset | `./references/datasets.md` |
| Inspect recipes, choose a recipe family, or ground a flow transformation | `./references/recipes.md` |
| Select which container one existing recipe, ML task, WebApp backend, Knowledge Bank, or agent tool runs in | `./references/container-execution.md` |
| Run an existing dataset or recipe, or track jobs, waits, and logs | `./references/jobs.md` |
| Inspect managed folders, create one on a chosen connection, or upload a user-supplied local file into one | `./references/managed_folders.md` |
| Inspect the project library or write one user-supplied local source file | `./references/project-libraries.md` |
| Inspect connections or choose a valid connection | `./references/connections.md` |
| Dataiku administrative tasks: (e.g. users, groups, code environments, general settings, etc.) | `./references/administration.md` |
| Inspect ML analyses, trained models, or saved models | `./references/machine-learning.md` |
| Inspect LLMs, Knowledge Banks, or RAG LLMs | `./references/llms-and-knowledge-banks.md` |
| Inspect agents or agent tools | `./references/agents.md` |
| Inspect Agent Reviews | `./references/agent-reviews.md` |
| Inspect dashboards | `./references/dashboards.md` |
| Inspect insights | `./references/insights.md` |
| Inspect scenarios and automation history, or run an existing scenario | `./references/scenarios.md` |
| Inspect semantic models | `./references/semantic-models.md` |
| Inspect WebApps and backend state | `./references/webapps.md` |
| Inspect wiki hierarchy or article content | `./references/wikis.md` |
| Inspect Data Quality rules and outcomes | `./references/data-quality.md` |
| Share a dataset from another project into the current project, or inspect cross-project sharing | `./references/cross-project-sharing.md` |
| Discover datasets through Data Collections | `./references/data-collections.md` |
| Port logic from Alteryx, SAS, Excel, or similar tools into Dataiku | `./references/migrations.md` |

## Routing Notes

- `./references/cobuild.md` is the default write path for in-project assets, but it should be grounded by the relevant guide first.
- Direct writes may grow over time for documented non-project, cross-project, instance-level, or administrative operations that Cobuild does not handle.
- `./references/jobs.md` is the follow-up guide after builds, runs, training, deployment, or other uncertain execution.

Referenced files: 62 — file references are metadata, not package contents.

View saved version →

---
name: dataiku-headless-setup
description: Set up Dataiku Headless after plugin installation. Use when the user asks to install, set up, connect, configure, or repair Dataiku Headless; when its MCP tools are unavailable; or when uv may be missing. Check the runtime, offer the official platform installer with explicit approval, then configure and verify a Dataiku instance.
---

# Set Up Dataiku Headless

Bring a new or broken plugin installation to a verified Dataiku connection. A request to set up Dataiku Headless is not approval to install software: obtain explicit approval immediately before running an installer.

## Workflow

1. First run `list_instances`. If it succeeds, the local plugin and runtime are already available; skip directly to instance configuration and verification below (step 8).
2. If the Dataiku MCP tools are unavailable, check the runtime. Run `uv --version` when local commands are available; ask the user to run it only when they are not. Dataiku Headless requires uv 0.12.0 or later.
3. If uv is missing or too old, explain briefly that it supplies the isolated Python runtime and pinned dependencies used by the local MCP server. Detect the operating system and offer the matching official Astral installer:
   - macOS or Linux: `curl -LsSf https://astral.sh/uv/install.sh | sh`
   - Windows PowerShell: `powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"`
4. Obtain explicit approval, run only the selected installer, and verify with `uv --version`. Do not substitute a third-party package manager or edit shell startup files unless the user asks.
5. If the current agent process cannot see the newly installed executable, use the installer's reported location to confirm it exists, then ask the user to fully restart or reload the agent. Stop and resume setup in the new session; the already-running MCP process cannot repair its own launch environment.
6. Once uv is suitable, warm the runtime by running the server once with stdin closed. Locate the absolute path of this `SKILL.md`; the plugin root is its ancestor containing both `skills/` and `runtime/` (this file is at `<plugin_root>/skills/dataiku-headless-setup/SKILL.md`). Do not assume the current working directory is the plugin root.
   - macOS or Linux: `uv run --quiet --locked --script "<plugin_root>/runtime/run_mcp.py" --transport stdio < /dev/null`
   - Windows PowerShell: `$null | uv run --quiet --locked --script "<plugin_root>\runtime\run_mcp.py" --transport stdio`

   A startup line on stderr followed by exit status 0 is expected. Do not substitute `uv sync --locked --script`: it caches downloads but leaves environment creation for the first server launch.
7. Retry `list_instances`. If the tools are still unavailable, reload the plugin or restart the agent once, then retry before diagnosing a Dataiku connection problem.
8. When `list_instances` succeeds, if no instance is configured, run `configure_instance` and have the user complete the local setup page. If multiple instances exist without an active one, ask which to use and run `switch_instance`.
9. Verify the active profile with `get_current_instance`. If its `connection_status` is `failed`, the discovered profile cannot connect to Dataiku; run `configure_instance` to replace or add a working profile instead of treating it as set up. When it is `connected`, make a lightweight read-only Dataiku call such as `list_projects` to validate the available Dataiku access. Never request or repeat the API key in chat.

Report completion with the active instance name, URL, and configured type, Dataiku version when available, and whether the Dataiku read succeeded. Include the uv version only when runtime recovery was needed. If a restart is required, say that setup is incomplete and give the single next action.