Skip to main content

Nexadata MCP Server Tool Reference

A reference for the Nexadata MCP server tools that manage organizations, workspaces, workflows, pipelines, transformations, and variables.

Once the Nexadata MCP server is connected to your AI client, you can manage your Nexadata resources through conversation. This article describes the tools the server provides, grouped by function. If you have not connected the server yet, start with the companion article on setup and authentication.

The tools below are exposed by both the production server (app.nexadata.com) and the staging server (staging.nexadata.com), so the same capabilities are available whether you are working against live or test data.

Connecting and Selecting an Organization

These tools establish which organization you are working in.

  • list_orgs lists every organization you are a member of. The currently preferred organization is marked, and a single-org user has that organization selected automatically.

  • select_org sets your preferred organization for subsequent requests and confirms the organization name, ID, and slug.

Exploring Workspaces, Connections, and Datasets

Use these tools to discover what already exists in your organization.

  • list_workspaces lists all workspaces in an organization, including each workspace's environments and lifecycle status.

  • list_connections lists data connections, with optional filters for name and connection type such as sftp or s3. Results are limited to 20.

  • search_datasets searches for datasets in an organization, with optional name and source type filters. Results are ordered by most recently updated and limited to 50.

  • preview_dataset downloads and displays the first 10 rows of a dataset, along with metadata and total row count.

Finding and Building Workflows

These tools let you locate workflows and assemble new ones.

  • list_workflows lists workflows within a specific workspace, with an optional name filter. Results are limited to 50.

  • workflow_lookup finds workflows by name across an organization and lists each workflow's pipelines, grouped into output pipelines and supporting pipelines. The primary output pipeline is tagged.

  • create_workflow creates a new workflow in a workspace and environment.

  • add_dataset_to_workflow associates a dataset with a workflow so it can feed pipelines.

  • create_output_pipeline creates an output pipeline within a workflow. It takes either a dataset or a supporting pipeline as its input. This is the tool to start with when building a pipeline unless you specifically need to pre-process data first.

  • create_supporting_pipeline creates a supporting pipeline within a workflow. Supporting pipelines process data from a dataset or another supporting pipeline, and their output can feed output pipelines. Use one when you need to pre-process data before joining it into an output pipeline.

  • create_default_output creates a default "Managed by Nexadata" output for a workflow that has no outputs defined. Because a workflow needs a default output before it can run, this is a quick way to make a workflow executable.

Note: When creating a pipeline, you must supply exactly one input source, either a dataset or a supporting pipeline.

Inspecting and Previewing Pipelines

These tools let you read the current state of a pipeline before, during, or after building it.

  • get_pipeline_transformations returns every transformation in a pipeline with full detail, including inputs, columns, data sources, and mapping groups. Use it to understand the complete transformation chain before making changes.

  • preview_pipeline previews the tabular data in a pipeline. By default it shows the final state after all transformations. When you supply a transformation ID, it shows the data up to and including that step, which is useful for checking your work as you build.

Building the Transformation Chain

Transformations are the individual steps that shape data inside a pipeline. Each of the tools below adds a step to a pipeline, and each returns the updated pipeline so you can confirm the result. Every transformation tool accepts an optional position to control where the step lands in the chain, and an optional transformation ID that edits an existing step instead of creating a new one.

Several transformation fields also accept variables, so you can reference workspace variables or generate dynamic dates inside a transformation rather than hardcoding values. See the "Using Variables in Transformations" article for the full syntax.

Adding and Positioning Columns

  • transformation_insert inserts a new column, populated with either a static value or a computed formula. Set the value type to scalar to write a fixed value, or to formula to compute the value from a simple expression. The supported formulas are intentionally simple: for logic that needs many conditional rules, a Mapping Group is usually a better fit. You control where the new column lands with a position operator of first, last, before, or after; the before and after options are placed relative to a reference column you name. The value and formula fields both accept variables.

  • transformation_copy copies an existing column into a new column under a different name. It uses the same first, last, before, and after positioning as insert.

  • transformation_insert_row_numbers adds a column of sequential row numbers, such as 1, 2, 3, with the same positioning options.

  • transformation_generate_unique_id adds a column of 32-character alphanumeric unique IDs, one per row (a UUID v4 value with the hyphens removed). Two parameters control the output:

    • seed makes the generated IDs deterministic and repeatable. Runs that use the same seed against the same data produce the same IDs, which is what allows the values to stay stable across executions rather than changing every run.

    • implementation_type chooses the generation method, either hash (IDs derived from row content) or prng (pseudo-random generation).

    As with the other column tools, you can position the new ID column using first, last, before, or after relative to a reference column.

  • transformation_shift moves an existing column to a new position, placed relative to another column.

Renaming, Keeping, and Removing Columns

  • transformation_rename renames a column.

  • transformation_keep keeps only the columns you specify and drops the rest.

  • transformation_remove drops the columns you specify.

Combining and Splitting Columns

  • transformation_merge combines several columns into one, joined by a delimiter, with the option to drop the original columns.

  • transformation_split splits one column into several columns using a delimiter, for example turning a full-name column into first-name and last-name columns.

Filtering and Sorting Rows

  • transformation_filter keeps only the rows that match the conditions you provide. Each condition compares a column, using an operator, against a value. The value can be a fixed value (a scalar comparator), the value of another column (a column comparator), or a percentile such as the top 20 percent (a percentage comparator). Conditions are grouped, and the group's combinator (and or or) determines whether every condition must pass or just one. Groups can be nested to build compound logic such as "A and (B or C)." The available operators are:

Operator

Meaning

gt

Greater than

gte

Greater than or equal to

lt

Less than

lte

Less than or equal to

eq

Equal to

neq

Not equal to

starts_with

Text begins with the value

ends_with

Text ends with the value

str_match

Text contains or matches the value

regex_match

Text matches a regular expression

empty

The value is empty or null

not_empty

The value is present

Note: Any regular expression used with regex_match must be compatible with the Polars engine. Look-around (look-ahead and look-behind) is not supported, so patterns using ?! or ?<= cannot be used.

  1. transformation_sort sorts rows by a column, ascending or descending, and lets you place empty values first or last.

Standardizing Text and Dates

  • transformation_lowercase converts the values in a column to lowercase.

  • transformation_uppercase converts the values in a column to uppercase.

  • transformation_replace performs a find-and-replace on a string column. It supports two replacement types:

    • exact replaces the entire cell value when it matches the input string exactly.

    • regex replaces text matching a regular expression.

    Note: transformation_replace does not perform wildcard or "like" matching. If you need fuzzy or pattern-style value substitution (for example, matching ry* to catch "ryan"), use a Mapping Group with the like match type instead. As with filtering, any regular expression must be Polars-compatible and cannot use look-ahead or look-behind (?! or ?<=).

  • transformation_parse_date converts date values from one format to another and can convert time zones. You provide an input format that describes the existing values and an output format for the result, both written as standard chrono strftime codes. The output format defaults to %Y-%m-%d %H:%M:%S if you do not specify one. Invalid or empty values become null. Common format codes:

Code

Meaning

%Y

Four-digit year

%m

Two-digit month

%d

Two-digit day

%H

Hour, 24-hour clock

%M

Minute

%S

Second

%s

Unix epoch time in seconds

%Q

Unix epoch time in milliseconds

To parse Unix timestamps, use %s (seconds) or %Q (milliseconds) as the input format. Epoch values are read as UTC. Time zones: the timezone parameter accepts any IANA time zone name, such as America/New_York or Europe/London, and defaults to Etc/UTC. Parsed dates are treated as UTC and then converted to the time zone you specify.

Working with Numbers

  • transformation_flip_sign multiplies the values in a numeric column by negative one, so positives become negatives and negatives become positives. Two capabilities extend the basic behavior:

    • Multiple columns. You can flip the sign of more than one column in a single step by listing each column.

    • Conditional flipping. You can attach conditions so the sign is flipped only on rows that meet criteria you define. Conditions use the same structure as the filter transformation, comparing a column against a value, another column, or a percentile, combined with and or or logic. This is useful for cases such as flipping the sign only where an amount type is "credit."

  • transformation_math_operation runs an aggregate calculation across a column and writes the result to a new column at a decimal precision you choose. The supported functions are sum, count, max, min, mean, median, mode, standard_deviation, and n_distinct.

Aggregating Rows

  • transformation_group_by groups rows by one or more columns and applies one or more aggregations, collapsing the data to one row per group (similar to GROUP BY in SQL). You can define several aggregations in a single step, each with its own source column, aggregation function, output column, and decimal precision. The available functions are sum, count, max, min, mean, median, mode, standard_deviation, and n_distinct.

    Note: Any grouping columns you want to keep for later steps must be included in the transformation's columns, or they will not be available downstream.

Combining Datasets

These tools bring a second dataset or supporting pipeline into a pipeline.

  • join_dataset joins another dataset or supporting pipeline to the pipeline's primary data on matching columns. You choose the join type (inner, left, right, or outer) and the columns to join on, and column types are auto-cast for compatibility by default.

  • stack_dataset stacks the rows of another dataset or supporting pipeline on top of the pipeline's current data, appending records.

Mapping Values

Mapping Groups translate the values in a column using an ordered set of rules, which is ideal for source-to-target value translation.

  • mapping_transformation creates or edits a Mapping Group and applies it to an existing column. Each rule is a find-and-replace defined by a match type, the value to match, and the result value to write when it matches. Rules run in order, and once a rule matches a value that value is not changed again, so place the most specific rules first. A Mapping Group transforms values in place rather than creating a new column, so rename the column afterward if you want a different name. The supported match types are:

Match type

Behavior

exact

Matches the full value exactly. Preferred when applicable because it is the easiest to reason about.

regex

Matches values against a regular expression.

like

Fuzzy or wildcard match, for example ry* to catch "ryan."

not_exact

Matches every value except an exact match.

not_like

Matches every value except a fuzzy match.

any

Matches all values. Requires conditions and is typically used to apply a result based only on other columns.

Each rule can also carry conditions that gate when it applies, based on the values in other columns. Conditions use the same comparator structure as the filter transformation (value, column, or percentile comparisons combined with and or or logic), so a rule can require, for example, that a status column equals "active" before the replacement is made. Matching is case-insensitive by default. Set the case-sensitive option to true when you need matches to respect letter casing.

  • mapping_group_lookup finds Mapping Groups by name within an organization.

Running and Monitoring Workflows

These tools trigger workflow runs and track their progress.

  • execute_workflow triggers a manual, background execution of a workflow. The run processes asynchronously, so the request returns execution details rather than waiting for completion.

  • workflow_execution_lookup looks up the status and details of a single execution, including state, timing, and any errors or warnings.

  • all_workflow_executions lists recent executions for a workflow, with optional filters for status, start date, and result limit.

Note: A workflow must have a default output pipeline configured before it can be executed. If it has none, run create_default_output first.

Reviewing Run Statistics

These tools surface the full statistics captured during execution.

  • fetch_workflow_run_statistics returns execution statistics for a workflow's runs, including timing, status, and the complete statistics for each execution.

  • fetch_pipeline_run_statistics returns the same level of detail for an individual pipeline's executions.

Note: Both tools support filtering by status and start date, and sorting by execution.

Auditing Changes

These tools show who changed what and when.

  • get_pipeline_edit_attribution returns the last editor and edit timestamp for a pipeline, plus recent version snapshots with their associated execution IDs.

  • get_mapping_group_edit_attribution returns edit history for a Mapping Group, showing property changes, added, changed, and deleted mapping rules, and column changes across recent versions.

Editing and Removing Transformations

  • delete_transformation removes a transformation from a pipeline and returns the updated pipeline state, so you can revise a transformation chain step by step. To change a step in place rather than remove it, pass its transformation ID to the relevant transformation tool instead.

Managing Workspace Variables

These tools manage the variables scoped to a workspace.

  • list_variables lists all variables in a workspace with their ID, name, type, and value.

  • update_variable updates the value of a workspace variable.

  • delete_variable removes a workspace variable.

Note: Authorization for variable tools is validated through the variable, workspace, and organization chain, so you can only modify variables in organizations you belong to.

Did this answer your question?