WeekendNoobs/pega-constellation-dx-sft

Pega Constellation DX Components — Training Dataset

This dataset teaches a code model how to write Pega Constellation DX components — the custom React/TypeScript components that extend the Pega Platform UI.

It comes from the open-source constellation-ui-gallery repo, which Pega itself maintains as a reference for DX component authors. We pinned a specific commit so the dataset is reproducible.

What is in it

55 Pega DX components, each broken into 9 different training tasks. Every component has the same folder layout (Pega_Extensions_<Name>/ with index.tsx, config.json, Docs.mdx, demo.stories.tsx, demo.test.tsx). The dataset shows the model all the pieces — code, config, docs, tests, stories — and how they fit together.

For the one big component (CPQTree — 23 files, real-world complexity), the dataset also captures the sub-components and hooks separately so the model sees how a non-trivial Pega DX component is structured.

License

Apache-2.0 — same as the source repo. You can use it for training, including commercial use. Just keep the copyright notice.

Source

• Repo: https://github.com/pegasystems/constellation-ui-gallery
• Pinned commit: ec4e69f6de1092bf0f276f0659ba90a7ed60675b
• Per-file URL pattern: https://github.com/pegasystems/constellation-ui-gallery/blob/<sha>/<path>

Citation

@software{pega_constellation_ui_gallery,
  title  = {Constellation UI Gallery},
  author = {Pegasystems Inc.},
  year   = {2024-2026},
  url    = {https://github.com/pegasystems/constellation-ui-gallery},
  note   = {Apache-2.0; pinned commit ec4e69f6de1092bf0f276f0659ba90a7ed60675b}
}

Files in this dataset

pega-constellation-dx-sft/
├── README.md                     ← you are here
├── system_prompt.txt             ← the constant instruction given to the model before every example
├── train.jsonl                   ← 389 rows for training
├── validation.jsonl              ← 24 rows for early stopping
├── test.jsonl                    ← 24 rows for final evaluation
├── to_parquet.py                 ← script that generated the parquet files
└── parquet/
    ├── train-00000-of-00001.parquet
    ├── validation-00000-of-00001.parquet
    └── test-00000-of-00001.parquet

Splits — what is in each one

split	components	rows	purpose
train	49 components	389	the data the model learns from
validation	ActionableButton, Banner, BarCode	24	held out — use during training to detect overfitting
test	CPQTree, ChatGenAI, Map	24	held out — use only at the end to measure how well the model generalizes

Components never appear in more than one split. The test set is the most important — if your model is good on the test set, it generalizes to Pega components it has never seen.

What each row looks like

Every row is a chat conversation with two messages — a user prompt and an assistant response. The model is trained to produce the assistant response when given the user prompt.

{
  "task": "docs_to_implementation",
  "component": "Pega_Extensions_Banner",
  "system": "<the Pega DX authoring rules — see system_prompt.txt>",
  "messages": [
    {"role": "user", "content": "Generate the index.tsx for Pega_Extensions_Banner..."},
    {"role": "assistant", "content": "import { withConfiguration, Banner } from ..."}
  ],
  "files_in_input": ["src/components/.../Docs.mdx", "src/components/.../config.json"],
  "files_in_output": ["src/components/.../index.tsx"],
  "source_url": "https://github.com/.../index.tsx",
  "pega_version": "25.1",
  "split": "train",
  "token_count": 3086,
  "row_id": "abc123..."
}

The 9 training tasks

Each component produces several rows — one per task. The model sees the same component from multiple angles.

task	what the model gets as input	what it has to produce
docs_to_implementation	the Docs.mdx + config.json	the index.tsx
config_to_implementation	the config.json	the index.tsx
implementation_to_config	the index.tsx	the config.json
implementation_to_docs	the index.tsx	the Docs.mdx
implementation_to_test	the index.tsx	the demo.test.tsx
implementation_to_story	the index.tsx	the demo.stories.tsx
requirement_to_implementation	a plain-English description of what the component should do	the index.tsx
full_component_bundle	the Docs.mdx	config + test + story + styles + localizations + utils (everything except index.tsx)
multi_file_implementation	the Docs.mdx	sub-components and hooks (CPQTree only)

Counts:

• 55 rows each for the 6 single-file code tasks
• 54 rows for implementation_to_test (Map has no test file)
• 52 rows for full_component_bundle (3 components exceed size limit)
• 1 row for multi_file_implementation (only CPQTree has sub-folders)

How to load it

Option 1 — JSONL

from datasets import load_dataset

ds = load_dataset(
    "json",
    data_files={
        "train":      "train.jsonl",
        "validation": "validation.jsonl",
        "test":       "test.jsonl",
    },
)

Option 2 — Parquet (smaller, faster, recommended for training)

from datasets import load_dataset

ds = load_dataset(
    "parquet",
    data_files={
        "train":      "parquet/train-00000-of-00001.parquet",
        "validation": "parquet/validation-00000-of-00001.parquet",
        "test":       "parquet/test-00000-of-00001.parquet",
    },
)

In the parquet files, the messages array is split into two separate columns: user and assistant. Training scripts can grab them directly without parsing JSON.

What was filtered out

The source repo has some noise that would have hurt training — these were stripped:

• buildDate field in every config.json — this is a snapshot timestamp that changes every build. The model would have memorized a stale date.
• PegaAboutLabel and PegaAboutData properties — these are auto-injected by the Pega build pipeline into every config.json. They are not real component properties. Without filtering, the model would have learned that every Pega component has an "About" field with the build version as its value.
• Properties marked format: LABEL — internal markers, not user-facing inputs.
• CPQTree's sample1.json and sample2.json — 372 KB of mock data, not code.
• CPQTree's DESIGN.md — internal design notes.
• Storybook static images, package-lock.json, node_modules — not source code.

Other quality rules:

• Files larger than 25,000 characters were skipped for tasks needing them as input/output.
• Total input + output larger than 32,000 characters was rejected.
• Assistant outputs shorter than 200 characters were dropped.
• implementation_to_config outputs were validated as parseable JSON.
• Code outputs were sanity-checked — they must end with a closing brace, semicolon, comment terminator, or JSX closing tag.

How to use it

For SFT or LoRA fine-tuning of code models — Qwen2.5-Coder, DeepSeek-Coder, Qwen3, Qwen3.5 — for Pega Constellation DX code generation.

The system prompt (in system_prompt.txt) is the same on every row. It encodes the project's conventions — folder layout, imports, the withConfiguration wrapper, the getPConnect typing, the MDX doc shape. Include it as the system message when training.

What this dataset will and will not do

Will do well — produce a Pega DX component that follows the conventions of the source repo. Folder naming, file structure, the withConfiguration wrapper, getPConnect typing, mock-object patterns for tests and stories, MDX doc structure. For 80% of "build me a Pega component like X" requests, this works.

Won't do well — there are gaps you should know about:

• No real customer requests in training. The "requirement" examples are generated from the config.json properties — they're structured, not messy. A user asking "build a banner that shows when a case is overdue and lets me dismiss it" is not in the dataset.
• No bad-code examples. The dataset shows the right way to write components but never the wrong way. The model won't learn what not to do.
• No error handling. Most components in the source are happy-path. The model won't learn defensive patterns for when getPConnect() returns null or the API fails.
• Limited variety. 55 components, all by the same Pega team, in one style. Other Pega teams might write differently.
• No accessibility patterns. ARIA, keyboard navigation, screen-reader support are not covered.
• Pega-specific only. Symbols like withConfiguration, getPConnect, PCore show up everywhere. Mixed with general code data this is fine — used alone, the model becomes a Pega DX specialist only.

Treat this as the foundation. For best results, after the initial training, add examples covering the gaps above (real user phrasings, error paths, bad-vs-good pairs).

Build

The dataset is reproducible. To regenerate it from scratch:

git clone https://github.com/pegasystems/constellation-ui-gallery
cd constellation-ui-gallery
git checkout ec4e69f6de1092bf0f276f0659ba90a7ed60675b
# then run the build_dataset.py script against this checkout

The build script lives in the source repository that produced this dataset. Search for it at the GitHub repo that hosts the build pipeline.