← Back to history

Pipeline run

0aa94386-7f59-430c-b6f7-8f25e5b5c76e

Pipeline LLM cost (USD)
API 1: $0.0052 API 2: $0.0008 API 3: $0.0000 Total: $0.0060

Client output enrichment

v2 Skill cluster · Nature of work · AI index · Tech stack maturity · Evidence · KRA description
Nature of work · Machine Learning Engineering
Owns production ML/LLM systems end to end: ships high-scale inference services, builds feature/training/serving pipelines, and implements RAG + LLM fine-tuning with monitoring, evaluation, and MLOps automation.
""Design and deploy production-grade ML services serving 50M+ predictions/day.""
Tech stack maturity
Modern Cloud Native
The skill set centers on contemporary ML infrastructure and deployment practices—CI/CD, MLflow, vector databases (pgvector, FAISS), PyTorch, and RAG—typical of modern cloud-native AI engineering.
AI index (0 = no AI use, 5 = totally AI-dependent · v2.1)
3.20 / 5
Title match
Has AI skill
AI skill (primary)
· AI skill (secondary)
· On AI team
· Builds AI products
vocab breakdown (legacy)
Assistants (×1):
Frameworks (×2): Hugging Face, Weaviate, Pinecone, pgvector, Ollama
Models / concepts (×3): Llama 3, Mistral, Transformers, RAG, embeddings, hybrid search, LLM, MLOps, ML, Machine Learning, Deep Learning
Evidence — skills matched in JD (30)
Python PyTorch Hugging Face Transformers Llama 3 Mistral RAG FAISS pgvector A/B Testing MLflow CI/CD TensorFlow JAX Pinecone Weaviate text-embedding-3 BGE vLLM TGI Triton Kubeflow Weights & Biases Airflow Prefect Kubernetes +5
Skill cluster (10 dimension groups, role-scoped)
ML Frameworks and Libraries
PyTorch FAISS TensorFlow JAX
LLM Operations and Orchestration
Pinecone vLLM
MLOps Platforms and Lifecycle
MLflow Kubeflow
Model Optimization and Acceleration
Triton Quantization
Workflow Orchestration for ML Pipelines
Airflow Prefect
CI/CD for Machine Learning
CI/CD
Experiment Tracking and Evaluation
Weights & Biases
Kubernetes for ML Workloads
Kubernetes
Programming Languages for ML Systems
Python
Cross-cutting / unaligned
Hugging Face Transformers Llama 3 Mistral RAG pgvector A/B Testing Weaviate text-embedding-3 BGE TGI GPU scheduling BM25 FP16 INT8
Show KRA description ↓
We are looking for a Senior ML Engineer to own the lifecycle of production machine-learning systems at our platform. You will work with applied scientists to take research models from notebook to production, build retrieval-augmented generation (RAG) pipelines on top of our internal document corpus, and own MLOps infrastructure end-to-end. - Design and deploy production-grade ML services serving 50M+ predictions/day. - Build feature stores, training pipelines, and online inference infrastructure with PyTorch and Hugging Face Transformers. - Lead our LLM efforts: fine-tune open-source models (Llama 3, Mistral) and integrate with our RAG retrieval layer (FAISS, pgvector embeddings). - Set up evaluation harnesses, A/B testing frameworks, and model monitoring/drift detection. - Mentor junior ML engineers on best practices for reproducible experiments, model versioning (MLflow), and CI/CD for ML. - 5+ years of hands-on ML engineering experience, with at least 2 years productionising deep-learning models. - Strong Python; production code with PyTorch, TensorFlow, or JAX. - Experience with vector databases (Pinecone, Weaviate, pgvector) and embedding models (text-embedding-3, BGE, etc.). - LLM serving experience: vLLM, TGI, or Triton. - Familiar with MLOps tooling (MLflow, Kubeflow, Weights & Biases) and orchestration (Airflow, Prefect). - Comfort with Kubernetes for ML workloads; experience with GPU scheduling preferred. - Open-source contributions to ML frameworks or popular LLM tooling. - Experience with retrieval-augmented generation, sparse retrieval (BM25), and hybrid search. - Familiarity with vector index tuning, quantization (INT8/FP16), and inference optimisation.

Signals

Skill ml-engineer
0.45
Alias ml-engineer
1.00
KRA ml-ops-engineer
0.63

Post-classification

Centroidupdated · n=15
Alias collision log
New-role queue
New skills captured9
New KRA captured

Captured for admin review

Hugging Face Transformers primary ML Engineer pending
Llama 3 primary ML Engineer pending
Mistral primary ML Engineer pending
text-embedding-3 ML Engineer pending
TGI ML Engineer pending
GPU scheduling ML Engineer pending
BM25 ML Engineer pending
FP16 ML Engineer pending
INT8 ML Engineer pending
Status: completed Created: 2026-05-23T10:45:03.042253Z Updated: 2026-05-23T10:45:30.479765Z API 3 duration: 10984 ms
Flow Current 3-step pipeline

1 POST /skills/extract-from-jd

2 POST /skills/extract-details

3 POST /skills/final-role-output

Role Chosen role & resolution

ML Engineer

CASE A

slug: ml-engineer · id: 3 · source: db

This role aligns with primary skills like Python, PyTorch, and multiple ML frameworks essential for machine learning tasks.

Resolution: in_db — role exists in library; skill↔dim and role↔dim links saved when applicable.

0
New skills
0
Skill↔dim saved
0
Role↔dim saved
1
Skipped

Job description

Job Title: Senior Machine Learning Engineer

About the role:
We are looking for a Senior ML Engineer to own the lifecycle of production machine-learning systems at our platform. You will work with applied scientists to take research models from notebook to production, build retrieval-augmented generation (RAG) pipelines on top of our internal document corpus, and own MLOps infrastructure end-to-end.

Responsibilities:
- Design and deploy production-grade ML services serving 50M+ predictions/day.
- Build feature stores, training pipelines, and online inference infrastructure with PyTorch and Hugging Face Transformers.
- Lead our LLM efforts: fine-tune open-source models (Llama 3, Mistral) and integrate with our RAG retrieval layer (FAISS, pgvector embeddings).
- Set up evaluation harnesses, A/B testing frameworks, and model monitoring/drift detection.
- Mentor junior ML engineers on best practices for reproducible experiments, model versioning (MLflow), and CI/CD for ML.

Requirements:
- 5+ years of hands-on ML engineering experience, with at least 2 years productionising deep-learning models.
- Strong Python; production code with PyTorch, TensorFlow, or JAX.
- Experience with vector databases (Pinecone, Weaviate, pgvector) and embedding models (text-embedding-3, BGE, etc.).
- LLM serving experience: vLLM, TGI, or Triton.
- Familiar with MLOps tooling (MLflow, Kubeflow, Weights & Biases) and orchestration (Airflow, Prefect).
- Comfort with Kubernetes for ML workloads; experience with GPU scheduling preferred.

Nice to have:
- Open-source contributions to ML frameworks or popular LLM tooling.
- Experience with retrieval-augmented generation, sparse retrieval (BM25), and hybrid search.
- Familiarity with vector index tuning, quantization (INT8/FP16), and inference optimisation.

Location: Bengaluru (Hybrid) | Comp: competitive.

Skills from this JD

Each row merges API 1 extraction, API 2 library match / v3 orchestration (dimensions + locked dims), and API 3 persistence tags.

Python Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Python id=5 · python

Aliases — catalog

  • Python (CANONICAL) primary
  • Python 2 (VERSION)
  • Python 2.x (VERSION)
  • Python 3 (VERSION)
  • Python 3.10 (VERSION)
  • Python 3.11 (VERSION)
  • Python 3.12 (VERSION)
  • Python 3.x (VERSION)
  • py (VERSION)
  • py2 (VERSION)
  • py3 (VERSION)
  • python 3 (VERSION)
  • python 3.x (VERSION)
  • python2 (VERSION)
  • python3 (VERSION)
  • python3.x (VERSION)

Context tags (catalog)

API Django FastAPI Flask Jupyter NumPy PEP 8 Pandas REST SQLAlchemy asyncio pandas pip pytest type hints venv virtualenv

Stored enrichment (catalog DB)

Category
Language
Sub-category
Programming Language
Vendor
PSF
License
mit
Year introduced
1991
Confidence
0.99
Version strategy
SEPARATE_ENTITY
Version tag
3

Maturity reasoning: Python appears in a very high volume of job descriptions across data, backend, automation, and ML roles, and remains a default hiring-pipeline language on major job boards and tech stacks.

Skill profile (library / DB)

Skill nature
LANGUAGE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
6
Sub-category id
96
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Cloud Security Scripting & DSL Languages Catalog dimension db id 248

    Library dimension (catalog)

    Roles linked in library: Cloud Security Engineer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Fullstack Developer

  • Programming Languages and Scripting Catalog dimension db id 59

    Library dimension (catalog)

    Roles linked in library: Cybersecurity Engineer

  • Programming Languages for Data Work Catalog dimension db id 21

    Library dimension (catalog)

    Roles linked in library: Data Engineer

  • Programming Languages for ML Systems Catalog dimension db id 39

    Library dimension (catalog)

    Roles linked in library: ML Engineer, ML Ops Engineer

  • Programming Languages for XR Catalog dimension db id 97

    Library dimension (catalog)

    Roles linked in library: AR/VR Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Security Scripting & DSL Languages
cloud-security-scripting-dsl-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages and Scripting
programming-languages-and-scripting
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for ML Systems
programming-languages-for-ml-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
PyTorch Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: PyTorch id=195 · pytorch

Aliases — catalog

  • PyTorch (CANONICAL) primary

Context tags (catalog)

CUDA DataLoader GPU GPU acceleration Hugging Face Lightning ONNX PyTorch Lightning ReLU Tensor TorchScript autograd backpropagation checkpointing deep learning distributed training loss functions mixed precision model training neural networks nn.Module optimizers tensor torchaudio torchscript torchvision transfer learning

Stored enrichment (catalog DB)

Category
Library
Sub-category
Machine Learning Library
Vendor
Meta
License
bsd
Year introduced
2016
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: PyTorch appears in a large volume of ML/AI job descriptions and is a standard framework in research and production, alongside TensorFlow and CUDA ecosystems.

Skill profile (library / DB)

Skill nature
LIBRARY
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
7
Sub-category id
156
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • ML Frameworks and Libraries Catalog dimension db id 40

    Library dimension (catalog)

    Roles linked in library: ML Engineer, ML Ops Engineer

  • Model Fine-Tuning & Adaptation Catalog dimension db id 212

    Library dimension (catalog)

    Roles linked in library: AI Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
ML Frameworks and Libraries
ml-frameworks-and-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Model Fine-Tuning & Adaptation
model-fine-tuning-adaptation
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
TensorFlow Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: TensorFlow id=196 · tensorflow

Aliases — catalog

  • TensorFlow (CANONICAL) primary
  • TF1 (VERSION)
  • TF2 (VERSION)
  • TensorFlow 1 (VERSION)
  • TensorFlow 1.x (VERSION)
  • TensorFlow 2 (VERSION)
  • TensorFlow 2.x (VERSION)
  • tensorflow 1 (VERSION)
  • tensorflow 1.x (VERSION)
  • tensorflow 2 (VERSION)
  • tensorflow 2.x (VERSION)
  • tensorflow v1 (VERSION)
  • tensorflow v2 (VERSION)
  • tf (VERSION)
  • tf1 (VERSION)
  • tf2 (VERSION)

Context tags (catalog)

AutoGraph Distributed Training Eager Execution Estimator GPU Gradient Descent Hyperparameter Tuning Keras ModelCheckpoint Neural Networks ONNX SavedModel TF Lite TF Serving TF.js TFX TPU TensorBoard TensorFlow Hub TensorFlow Lite TensorFlow Serving Transfer Learning XLA tf.data tf.keras

Stored enrichment (catalog DB)

Category
Library
Sub-category
Machine Learning Library
Vendor
Google
License
apache_2
Year introduced
2015
Confidence
0.90
Version strategy
SEPARATE_ENTITY
Version tag
2.x

Maturity reasoning: TensorFlow appears in many ML/AI job descriptions and remains a standard production framework, with strong GitHub activity and broad vendor support from Google and cloud platforms.

Skill profile (library / DB)

Skill nature
LIBRARY
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
7
Sub-category id
156
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • ML Frameworks and Libraries Catalog dimension db id 40

    Library dimension (catalog)

    Roles linked in library: ML Engineer, ML Ops Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
ML Frameworks and Libraries
ml-frameworks-and-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JAX Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: JAX id=199 · jax

Aliases — catalog

  • JAX (CANONICAL) primary

Context tags (catalog)

Flax GPU Haiku NumPy Optax PyTree TPU XLA accelerator autograd functional programming grad jit pmap vmap

Stored enrichment (catalog DB)

Category
Library
Sub-category
Machine Learning Library
Vendor
Google
License
apache_2
Year introduced
2018
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: JAX appears increasingly in ML/AI job postings and research codebases, especially for high-performance training and TPU/GPU workloads, but it is not yet a universal hiring staple like PyTorch or TensorFlow.

Skill profile (library / DB)

Skill nature
LIBRARY
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
7
Sub-category id
156
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • ML Frameworks and Libraries Catalog dimension db id 40

    Library dimension (catalog)

    Roles linked in library: ML Engineer, ML Ops Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
ML Frameworks and Libraries
ml-frameworks-and-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Hugging Face Transformers Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Machine Learning Frameworks
Sub-category
general
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Llama 3 Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Machine Learning Frameworks
Sub-category
general
Skill nature
TOOL
Volatility
FAST
Typical lifespan
SHORT_LIVED
Version strategy
VERSIONED
Mistral Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Machine Learning Frameworks
Sub-category
general
Skill nature
TOOL
Volatility
FAST
Typical lifespan
SHORT_LIVED
Version strategy
VERSIONED
RAG Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: RAG id=1194 · rag

Aliases — catalog

  • RAG (CANONICAL)

Context tags (catalog)

AI applications contextualization data augmentation fine-tuning generation information retrieval knowledge integration machine learning model training natural language processing prompt engineering retrieval semantic search transformer models user intent

Stored enrichment (catalog DB)

Category
Concept
Sub-category
Retrieval Augmented Generation
Confidence
0.93
Version strategy
NOT_APPLICABLE

Maturity reasoning: RAG appears in many recent AI/ML job descriptions and vendor docs, but it is still not a universal baseline skill like Python or SQL; market demand is rising fast rather than fully standardized.

Skill profile (library / DB)

Skill nature
CONCEPT
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
2
Sub-category id
904
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
FAISS Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: FAISS id=1184 · faiss

Aliases — catalog

  • FAISS (CANONICAL)

Context tags (catalog)

GPU acceleration approximate nearest neighbors clustering data retrieval embedding high-dimensional indexing machine learning nearest neighbor performance tuning quantization scalability search algorithms similarity search vector search

Stored enrichment (catalog DB)

Category
Library
Sub-category
Vector Search Library
Vendor
Facebook
License
apache_2
Year introduced
2017
Confidence
0.93
Version strategy
NOT_APPLICABLE

Maturity reasoning: FAISS appears in growing number of AI/vector-search job descriptions and is widely used in RAG stacks, but it is still less universal than PostgreSQL or Kubernetes and often paired with managed vector DBs.

Skill profile (library / DB)

Skill nature
LIBRARY
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
7
Sub-category id
894
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • ML Frameworks and Libraries Catalog dimension db id 40

    Library dimension (catalog)

    Roles linked in library: ML Engineer, ML Ops Engineer

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
ML Frameworks and Libraries
ml-frameworks-and-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
pgvector Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: pgvector id=1246 · pgvector

Aliases — catalog

  • pgvector (CANONICAL) primary

Context tags (catalog)

AI integration JSONB PostgreSQL data analytics data retrieval database extension embedding full-text search high-dimensional data indexing machine learning nearest neighbors query optimization similarity search vector search

Stored enrichment (catalog DB)

Category
Library
Sub-category
Database Extension Library
Vendor
ZomboDB
License
mit
Year introduced
2021
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: Appears in growing numbers of JDs for AI search/RAG roles, but remains a PostgreSQL extension rather than a universal database skill; GitHub adoption is rising yet still far below core DB tech.

Skill profile (library / DB)

Skill nature
LIBRARY
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
7
Sub-category id
972
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Vector Databases Catalog dimension db id 198

    Library dimension (catalog)

    Roles linked in library: AI Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Vector Databases
vector-databases
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
A/B Testing Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: A/B Testing id=1613 · a-b-testing

Aliases — catalog

  • A/B Testing (CANONICAL)

Context tags (catalog)

click-through rate control group conversion rate data analysis experiment framework hypothesis testing landing page multivariate testing performance metrics result interpretation sample size split testing statistical significance user segmentation variant

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Experiment Design Methodology
Confidence
0.97
Version strategy
NOT_APPLICABLE

Maturity reasoning: Commonly listed in product, growth, and analytics job descriptions; major platforms like Optimizely and Google Optimize popularized it, and it remains a standard experimentation practice across SaaS and e-commerce.

Skill profile (library / DB)

Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
8
Sub-category id
1214
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

  • Systems Programming Catalog dimension db id 166

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Systems Programming
d_init_02
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
MLflow Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: MLflow id=214 · mlflow

Aliases — catalog

  • MLflow (CANONICAL) primary

Context tags (catalog)

A/B testing API Databricks ML pipeline UI artifact store artifacts data lineage deployment experiment tracking experiments feature store flavors hyperparameter tuning integration logging model lineage model registry model serving model versioning pipelines reproducibility run tracking scalability tracking training jobs versioning

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Mlops Tool
Vendor
Databricks
License
apache_2
Year introduced
2018
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: MLflow appears frequently in MLOps job descriptions and is a standard open-source model tracking/registry tool; Databricks continues to invest in it, signaling broad adoption rather than niche use.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
13
Sub-category id
1168
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • MLOps Platforms and Lifecycle Catalog dimension db id 43

    Library dimension (catalog)

    Roles linked in library: ML Engineer, ML Ops Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
MLOps Platforms and Lifecycle
mlops-platforms-and-lifecycle
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: CI/CD id=1190 · ci-cd

Aliases — catalog

  • CI/CD (CANONICAL)

Context tags (catalog)

Ansible CircleCI Docker GitLab CI Jenkins Kubernetes Terraform Travis CI automated testing build automation continuous deployment continuous integration deployment pipelines monitoring version control

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Ci Cd Process
Confidence
0.93
Version strategy
NOT_APPLICABLE

Maturity reasoning: CI/CD appears in a large share of software engineering JDs and is a standard requirement across DevOps, platform, and backend roles; major vendors like GitHub, GitLab, and AWS all center product roadmaps on CI/CD pipelines.

Skill profile (library / DB)

Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
8
Sub-category id
900
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • CI/CD Pipeline Platforms Catalog dimension db id 150

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • CI/CD for Machine Learning Catalog dimension db id 56

    Library dimension (catalog)

    Roles linked in library: ML Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD for Machine Learning
ci-cd-for-machine-learning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Pinecone Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Pinecone id=242 · pinecone

Aliases — catalog

  • Pinecone (CANONICAL) primary

Context tags (catalog)

ANN API integration LangChain OpenAI embeddings RAG analytics cloud-native data pipelines data retrieval distributed architecture embedding embeddings high-dimensional data indexing machine learning metadata filtering metadata management namespace nearest neighbor performance tuning query optimization real-time indexing retrieval augmented generation scalability semantic search similarity search upsert vector index vector search

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Vector Database Platform
Vendor
Pinecone
License
unknown
Year introduced
2021
Confidence
0.95
Version strategy
NOT_APPLICABLE

Maturity reasoning: Pinecone appears in a growing number of AI/vector-search job postings and vendor docs, but it is still far from universal compared with PostgreSQL or AWS.

Skill profile (library / DB)

Skill nature
PLATFORM
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
9
Sub-category id
177
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • LLM Operations and Orchestration Catalog dimension db id 49

    Library dimension (catalog)

    Roles linked in library: AI Engineer, ML Engineer, ML Ops Engineer

  • Vector Databases Catalog dimension db id 198

    Library dimension (catalog)

    Roles linked in library: AI Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
LLM Operations and Orchestration
llm-operations-and-orchestration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Vector Databases
vector-databases
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Weaviate Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Weaviate id=1242 · weaviate

Aliases — catalog

  • Weaviate (CANONICAL) primary

Context tags (catalog)

KNN RESTful API cloud-native data ingestion data modeling embedding graphQL machine learning open-source real-time analytics scalability schema semantic search vector search vectorization

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Vector Database Platform
Vendor
Weaviate
License
apache_2
Year introduced
2018
Confidence
0.95
Version strategy
NOT_APPLICABLE

Maturity reasoning: Weaviate appears in a growing number of AI/vector-search job postings and vendor docs, but JD volume is still far below PostgreSQL/AWS-level staples; GitHub activity and ecosystem integrations are rising.

Skill profile (library / DB)

Skill nature
PLATFORM
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
9
Sub-category id
177
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Vector Databases Catalog dimension db id 198

    Library dimension (catalog)

    Roles linked in library: AI Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Vector Databases
vector-databases
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
text-embedding-3 Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: text-embedding-3-large id=1252 · text-embedding-3-large

Aliases — catalog

  • text-embedding-3-large (CANONICAL) primary

Context tags (catalog)

API integration contextual embeddings data preprocessing feature extraction fine-tuning information retrieval language understanding machine learning model training natural language processing semantic search similarity scoring text classification transformer models vector search

Stored enrichment (catalog DB)

Category
Service
Sub-category
Embedding Model Service
Vendor
OpenAI
License
proprietary
Year introduced
2023
Confidence
0.94
Version strategy
SEPARATE_ENTITY
Version tag
text-embedding-3-large

Maturity reasoning: OpenAI’s text-embedding-3-large is appearing in RAG/vector-search job posts and docs, but JD volume is still far below core skills like Python/AWS and it’s a newer model family rather than a universal standard.

Skill profile (library / DB)

Skill nature
CLOUD_SERVICE
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
11
Sub-category id
1005
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Embedding Models Catalog dimension db id 199

    Library dimension (catalog)

    Roles linked in library: AI Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Embedding Models
embedding-models
Skipped — no persistable v3 meta for new skill
skill_not_in_db_v3_proposed
BGE Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: BGE id=1249 · bge

Aliases — catalog

  • BGE (CANONICAL) primary

Context tags (catalog)

API integration contextual understanding data retrieval embedding techniques feature extraction fine-tuning information retrieval knowledge graph machine learning model training natural language processing semantic search similarity scoring transformer models vector embeddings

Stored enrichment (catalog DB)

Category
Library
Sub-category
Embedding Model Library
Vendor
Hugging Face
License
apache_2
Year introduced
2020
Confidence
0.82
Version strategy
NOT_APPLICABLE

Maturity reasoning: BGE is increasingly listed in LLM/RAG job descriptions and widely used in GitHub examples for embeddings, but it is not yet a universal hiring staple like AWS or PostgreSQL.

Skill profile (library / DB)

Skill nature
LIBRARY
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
7
Sub-category id
973
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Embedding Models Catalog dimension db id 199

    Library dimension (catalog)

    Roles linked in library: AI Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Embedding Models
embedding-models
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
vLLM Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: vLLM id=241 · vllm

Aliases — catalog

  • vLLM (CANONICAL) primary

Context tags (catalog)

API integration CUDA GPU acceleration GPU inference Hugging Face KV cache Kubernetes LoRA OpenAI-compatible API PyTorch REST API TensorFlow batch processing cloud deployment cloud-native containerization continuous batching deployment distributed systems gRPC inference inference optimization latency optimization load balancing microservices model serving model versioning paged attention performance tuning pipeline parallelism quantization real-time processing scalability speculative decoding tensor parallelism transformers

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Llm Inference Server
Vendor
vllm
License
apache_2
Year introduced
2023
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: vLLM appears in growing numbers of LLM infra job postings and is widely referenced in GitHub/OSS deployments, but it is not yet a universal hiring staple like Kubernetes or AWS.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
13
Sub-category id
1167
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • LLM Operations and Orchestration Catalog dimension db id 49

    Library dimension (catalog)

    Roles linked in library: AI Engineer, ML Engineer, ML Ops Engineer

  • LLM Serving & Deployment Catalog dimension db id 209

    Library dimension (catalog)

    Roles linked in library: AI Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
LLM Operations and Orchestration
llm-operations-and-orchestration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
LLM Serving & Deployment
llm-serving-deployment
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
TGI Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Machine Learning Frameworks
Sub-category
general
Skill nature
TOOL
Volatility
FAST
Typical lifespan
SHORT_LIVED
Version strategy
VERSIONED
Triton Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Triton id=1367 · triton

Aliases — catalog

  • Triton (CANONICAL)

Context tags (catalog)

CUDA GPU acceleration algorithm optimization compute shaders deep learning hardware acceleration kernel memory management model optimization parallel computing performance tuning profiling synchronization tensor operations

Stored enrichment (catalog DB)

Category
Language
Sub-category
Gpu Kernel Language
Vendor
NVIDIA
License
other_open
Year introduced
2015
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: Triton appears in growing ML systems job postings and is increasingly used in open-source GPU kernel repos, but it is still far from a universal hiring staple like CUDA.

Skill profile (library / DB)

Skill nature
LANGUAGE
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
6
Sub-category id
1033
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Model Optimization and Acceleration Catalog dimension db id 53

    Library dimension (catalog)

    Roles linked in library: ML Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Model Optimization and Acceleration
model-optimization-and-acceleration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kubeflow Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Kubeflow id=213 · kubeflow

Aliases — catalog

  • Kubeflow (CANONICAL) primary
  • Kubeflow 1.x (VERSION)
  • Kubeflow 2.x (VERSION)
  • Kubeflow v1 (VERSION)
  • Kubeflow v2 (VERSION)

Context tags (catalog)

Argo Argo Workflows CI/CD Data preprocessing GPU scheduling Hyperparameter tuning Istio Jupyter notebooks KFServing Katib Kubeflow Pipelines Kubeflow Training Kubernetes ML pipelines MLOps MLflow MinIO Model serving Pipeline components PyTorch Seldon Seldon Core TensorFlow model serving

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Mlops Framework
Vendor
Google
License
apache_2
Year introduced
2017
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: Kubeflow appears in some MLOps/ML platform JDs, but far less often than Kubernetes or managed ML platforms; GitHub activity is steady yet adoption remains specialized to ML infrastructure teams.

Skill profile (library / DB)

Skill nature
FRAMEWORK
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
5
Sub-category id
1127
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • MLOps Platforms and Lifecycle Catalog dimension db id 43

    Library dimension (catalog)

    Roles linked in library: ML Engineer, ML Ops Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
MLOps Platforms and Lifecycle
mlops-platforms-and-lifecycle
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Weights & Biases Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Weights & Biases id=215 · weights-biases

Aliases — catalog

  • Weights & Biases (CANONICAL) primary

Context tags (catalog)

API integration CI/CD MLflow PyTorch TensorBoard TensorFlow artifacts automated logging collaborative projects dashboard data versioning dataset versioning experiment tracking hyperparameter sweeps hyperparameter tuning integrations machine learning metrics logging model checkpoints model management model registry notebooks performance metrics reproducibility run history team collaboration training pipelines training runs visualization tools

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Experiment Tracking Platform
Vendor
Weights & Biases, Inc.
License
other_open
Year introduced
2018
Confidence
0.97
Version strategy
NOT_APPLICABLE

Maturity reasoning: Frequently appears in ML/LLM job descriptions and vendor docs, but is still less universal than core cloud/ML stack tools; GitHub and ecosystem adoption are growing, not yet hiring-pipeline staple.

Skill profile (library / DB)

Skill nature
PLATFORM
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
9
Sub-category id
171
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Experiment Tracking and Evaluation Catalog dimension db id 44

    Library dimension (catalog)

    Roles linked in library: ML Engineer, ML Ops Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Experiment Tracking and Evaluation
experiment-tracking-and-evaluation
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Airflow Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Airflow id=265 · airflow

Aliases — catalog

  • Airflow (CANONICAL) primary
  • airflow 2 (VERSION)
  • airflow-2 (VERSION)
  • airflow2 (VERSION)
  • airflow2.x (VERSION)
  • apache airflow 2 (VERSION)

Context tags (catalog)

Apache Celery CeleryExecutor DAG ETL Executor Jinja templating Python SLA Sensors UI XCom backfill connections data pipeline executor hooks logging monitoring operators plugins scheduler task dependencies task instance variables

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Workflow Orchestration Tool
Vendor
Apache Software Foundation
License
apache_2
Year introduced
2014
Confidence
0.95
Version strategy
SEPARATE_ENTITY
Version tag
2.x

Maturity reasoning: Apache Airflow appears in many data engineering job postings and is a common orchestration choice in production stacks; its GitHub activity and ecosystem remain strong, with no vendor sunset or clear replacement dominating JDs.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
13
Sub-category id
130
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Workflow Orchestration for ML Pipelines Catalog dimension db id 54

    Library dimension (catalog)

    Roles linked in library: ML Engineer, ML Ops Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Workflow Orchestration for ML Pipelines
workflow-orchestration-for-ml-pipelines
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Prefect Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Prefect id=112 · prefect

Aliases — catalog

  • Prefect (CANONICAL) primary

Context tags (catalog)

DAG ETL Kubernetes Prefect Cloud Prefect Server Python agents blocks cron data engineering data pipelines deployment deployments execution environments flow flow management flow runs flows monitoring observability orchestration parameterization retry policies retry policy schedules scheduling state management task retries task runner task scheduling tasks work pools work queues workflow automation

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Workflow Orchestration Tool
Vendor
Prefect Technologies, Inc.
License
apache_2
Year introduced
2018
Confidence
0.95
Version strategy
NOT_APPLICABLE

Maturity reasoning: Prefect appears in growing numbers of data/ML workflow orchestration JDs, but Airflow remains the more common baseline; GitHub activity and vendor docs show active adoption rather than sunset.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
EMERGING
Typical lifespan
EVERGREEN
Category id
13
Sub-category id
130
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Data Pipeline Orchestration Catalog dimension db id 23

    Library dimension (catalog)

    Roles linked in library: Data Engineer

  • Workflow Orchestration for ML Pipelines Catalog dimension db id 54

    Library dimension (catalog)

    Roles linked in library: ML Engineer, ML Ops Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Data Pipeline Orchestration
data-pipeline-orchestration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Workflow Orchestration for ML Pipelines
workflow-orchestration-for-ml-pipelines
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kubernetes Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Kubernetes id=726 · kubernetes

Aliases — catalog

  • Kubernetes (CANONICAL) primary
  • Kubernetes 1.0+ (VERSION)
  • Kubernetes 1.x (VERSION)
  • Kubernetes v1 (VERSION)
  • k8s (VERSION)
  • kubernetes 1.x (VERSION)
  • kubernetes latest (VERSION)

Context tags (catalog)

CI/CD Cluster Autoscaler ConfigMap DaemonSet Deployment Docker Grafana Helm Ingress Istio K8s Kubelet Namespace Pod Prometheus RBAC Secret Service StatefulSet containerization deployment etcd kubectl load balancing microservices namespace orchestration persistent storage scalability service mesh

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Container Orchestration Platform
Vendor
Cloud Native Computing Foundation
License
apache_2
Year introduced
2014
Confidence
0.90
Version strategy
SEPARATE_ENTITY
Version tag
1.30

Maturity reasoning: Broadly adopted in cloud-native stacks; Kubernetes appears in a large share of DevOps/SRE job descriptions and is the default orchestration platform across major cloud vendors.

Skill profile (library / DB)

Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
9
Sub-category id
557
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Container Orchestration Platforms Catalog dimension db id 134

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, DevOps Engineer

  • Kubernetes for ML Workloads Catalog dimension db id 47

    Library dimension (catalog)

    Roles linked in library: ML Engineer, ML Ops Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Container Orchestration Platforms
container-orchestration-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kubernetes for ML Workloads
kubernetes-for-ml-workloads
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GPU scheduling Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Infrastructure Tools
Sub-category
general
Skill nature
CONCEPT
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
BM25 Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Information Retrieval
Sub-category
general
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
UNVERSIONED
Quantization Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: quantization id=260 · quantization

Aliases — catalog

  • quantization (CANONICAL) primary

Context tags (catalog)

DCT FP16 H.264 INT8 MPEG ONNX Runtime TFLite TensorRT adaptive quantization bitrate calibration codec compression artifacts edge deployment entropy coding frame rate inference latency lossless lossy mixed precision model compression post-training quantization pruning quantization matrix quantization-aware training scaling factors sparsity video bitrate video encoding weight sharing

Stored enrichment (catalog DB)

Category
Concept
Sub-category
Video Compression Concept
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: Quantization is a core video-compression concept used in MPEG/H.264/H.265 pipelines and widely referenced in codec docs and job specs for video/ML compression work.

Skill profile (library / DB)

Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
2
Sub-category id
1282
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Model Optimization and Acceleration Catalog dimension db id 53

    Library dimension (catalog)

    Roles linked in library: ML Engineer

  • Video Compression Algorithms Catalog dimension db id 226

    Library dimension (catalog)

    Roles linked in library: Video Codec Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Model Optimization and Acceleration
model-optimization-and-acceleration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Video Compression Algorithms
video-compression-algorithms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
FP16 Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Machine Learning Frameworks
Sub-category
general
Skill nature
CONCEPT
Volatility
FAST
Typical lifespan
SHORT_LIVED
Version strategy
VERSIONED
INT8 Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

No Stage 7 enrichment blob on this skill (orchestrator skipped enrichment).

Derived legacy fields
Category
Machine Learning Frameworks
Sub-category
general
Skill nature
CONCEPT
Volatility
FAST
Typical lifespan
SHORT_LIVED
Version strategy
VERSIONED

All API 3 persistence rows

Same grid as the skill-extractor “Persistence items” table: one row per (skill × dimension) work item.

Skill Tag Dimension Skill↔dim Role↔dim Outcome Notes
Python in_db
Cloud Security Scripting & DSL Languages
cloud-security-scripting-dsl-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages and Scripting
programming-languages-and-scripting
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages for ML Systems
programming-languages-for-ml-systems
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Python in_db
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
PyTorch in_db
ML Frameworks and Libraries
ml-frameworks-and-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
PyTorch in_db
Model Fine-Tuning & Adaptation
model-fine-tuning-adaptation
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
TensorFlow in_db
ML Frameworks and Libraries
ml-frameworks-and-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JAX in_db
ML Frameworks and Libraries
ml-frameworks-and-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
RAG in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
FAISS in_db
ML Frameworks and Libraries
ml-frameworks-and-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
FAISS in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
pgvector in_db
Vector Databases
vector-databases
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
A/B Testing in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
A/B Testing in_db
Systems Programming
d_init_02
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
MLflow in_db
MLOps Platforms and Lifecycle
mlops-platforms-and-lifecycle
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD in_db
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD in_db
CI/CD for Machine Learning
ci-cd-for-machine-learning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Pinecone in_db
LLM Operations and Orchestration
llm-operations-and-orchestration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Pinecone in_db
Vector Databases
vector-databases
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Weaviate in_db
Vector Databases
vector-databases
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
text-embedding-3 new
Embedding Models
embedding-models
Skipped — no persistable v3 meta for new skill skill_not_in_db_v3_proposed
BGE in_db
Embedding Models
embedding-models
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
vLLM in_db
LLM Operations and Orchestration
llm-operations-and-orchestration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
vLLM in_db
LLM Serving & Deployment
llm-serving-deployment
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Triton in_db
Model Optimization and Acceleration
model-optimization-and-acceleration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kubeflow in_db
MLOps Platforms and Lifecycle
mlops-platforms-and-lifecycle
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Weights & Biases in_db
Experiment Tracking and Evaluation
experiment-tracking-and-evaluation
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Airflow in_db
Workflow Orchestration for ML Pipelines
workflow-orchestration-for-ml-pipelines
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Prefect in_db
Data Pipeline Orchestration
data-pipeline-orchestration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Prefect in_db
Workflow Orchestration for ML Pipelines
workflow-orchestration-for-ml-pipelines
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kubernetes in_db
Container Orchestration Platforms
container-orchestration-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kubernetes in_db
Kubernetes for ML Workloads
kubernetes-for-ml-workloads
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Quantization in_db
Model Optimization and Acceleration
model-optimization-and-acceleration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Quantization in_db
Video Compression Algorithms
video-compression-algorithms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Library artifacts (this run)

Kind Detail DB id
canonical_skill_proposed Hugging Face Transformers | type=Machine Learning Frameworks subtype=general nature=TOOL lifespan=MULTI_YEAR
canonical_skill_proposed Llama 3 | type=Machine Learning Frameworks subtype=general nature=TOOL lifespan=SHORT_LIVED
canonical_skill_proposed Mistral | type=Machine Learning Frameworks subtype=general nature=TOOL lifespan=SHORT_LIVED
canonical_skill_proposed TGI | type=Machine Learning Frameworks subtype=general nature=TOOL lifespan=SHORT_LIVED
canonical_skill_proposed GPU scheduling | type=Infrastructure Tools subtype=general nature=CONCEPT lifespan=MULTI_YEAR
canonical_skill_proposed BM25 | type=Information Retrieval subtype=general nature=CONCEPT lifespan=EVERGREEN
canonical_skill_proposed FP16 | type=Machine Learning Frameworks subtype=general nature=CONCEPT lifespan=SHORT_LIVED
canonical_skill_proposed INT8 | type=Machine Learning Frameworks subtype=general nature=CONCEPT lifespan=SHORT_LIVED
dimension_skill_link_proposed text-embedding-3 ↔ Embedding Models
nano JD Parser — gpt-4.1-nano click to toggle
RoleSenior Machine Learning Engineer
Experience5+ years of hands-on ML engineering experience, with at least 2 years productionising deep-learning models.
CTC{'max': None, 'min': None, 'raw': 'competitive', 'period': None, 'currency': None}
DomainSoftware & SaaS Products
Location Bengaluru, India (hybrid)
JD type pass
Show raw JSON
{
  "JD_type": "pass",
  "about_company": null,
  "certifications": [],
  "company_name": null,
  "ctc": {
    "currency": null,
    "max": null,
    "min": null,
    "period": null,
    "raw": "competitive"
  },
  "domain": {
    "primary": {
      "aliases": [],
      "domain": "Software \u0026 SaaS Products"
    },
    "secondary": null
  },
  "education": [],
  "experience": {
    "max": null,
    "min": 5,
    "raw": "5+ years of hands-on ML engineering experience, with at least 2 years productionising deep-learning models."
  },
  "job_locations": [
    {
      "aliases": [
        "Bangalore"
      ],
      "city": "Bengaluru",
      "country": "India",
      "state": null,
      "work_mode": "hybrid"
    }
  ],
  "role": "Senior Machine Learning Engineer",
  "role_aliases": [
    "ML Engineer",
    "Machine Learning Engineer",
    "Senior ML Engineer"
  ],
  "role_archetype": "Data",
  "roles_and_responsibilities": [
    {
      "bullet_count": 0,
      "heading": "About the role",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "We are looking for a",
        "last_5_words": "infrastructure end-to-end."
      },
      "text": "We are looking for a Senior ML Engineer to own the lifecycle of production machine-learning systems at our platform. You will work with applied scientists to take research models from notebook to production, build retrieval-augmented generation (RAG) pipelines on top of our internal document corpus, and own MLOps infrastructure end-to-end.",
      "word_count": 49
    },
    {
      "bullet_count": 5,
      "heading": "Responsibilities",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "Design and deploy production-grade",
        "last_5_words": "versioning (MLflow), and CI/CD for ML."
      },
      "text": "- Design and deploy production-grade ML services serving 50M+ predictions/day.\n- Build feature stores, training pipelines, and online inference infrastructure with PyTorch and Hugging Face Transformers.\n- Lead our LLM efforts: fine-tune open-source models (Llama 3, Mistral) and integrate with our RAG retrieval layer (FAISS, pgvector embeddings).\n- Set up evaluation harnesses, A/B testing frameworks, and model monitoring/drift detection.\n- Mentor junior ML engineers on best practices for reproducible experiments, model versioning (MLflow), and CI/CD for ML.",
      "word_count": 104
    },
    {
      "bullet_count": 6,
      "heading": "Requirements",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "5+ years of hands-on ML",
        "last_5_words": "experience with GPU scheduling preferred."
      },
      "text": "- 5+ years of hands-on ML engineering experience, with at least 2 years productionising deep-learning models.\n- Strong Python; production code with PyTorch, TensorFlow, or JAX.\n- Experience with vector databases (Pinecone, Weaviate, pgvector) and embedding models (text-embedding-3, BGE, etc.).\n- LLM serving experience: vLLM, TGI, or Triton.\n- Familiar with MLOps tooling (MLflow, Kubeflow, Weights \u0026 Biases) and orchestration (Airflow, Prefect).\n- Comfort with Kubernetes for ML workloads; experience with GPU scheduling preferred.",
      "word_count": 104
    },
    {
      "bullet_count": 3,
      "heading": "Nice to have",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "Open-source contributions to ML",
        "last_5_words": "quantization (INT8/FP16), and inference optimisation."
      },
      "text": "- Open-source contributions to ML frameworks or popular LLM tooling.\n- Experience with retrieval-augmented generation, sparse retrieval (BM25), and hybrid search.\n- Familiarity with vector index tuning, quantization (INT8/FP16), and inference optimisation.",
      "word_count": 45
    }
  ],
  "urls": []
}
API 1 — extract-from-jd click to toggle
{
  "final_skills": [
    {
      "is_primary": true,
      "skill_name": "Python"
    },
    {
      "is_primary": true,
      "skill_name": "PyTorch"
    },
    {
      "is_primary": false,
      "skill_name": "TensorFlow"
    },
    {
      "is_primary": false,
      "skill_name": "JAX"
    },
    {
      "is_primary": true,
      "skill_name": "Hugging Face Transformers"
    },
    {
      "is_primary": true,
      "skill_name": "Llama 3"
    },
    {
      "is_primary": true,
      "skill_name": "Mistral"
    },
    {
      "is_primary": true,
      "skill_name": "RAG"
    },
    {
      "is_primary": true,
      "skill_name": "FAISS"
    },
    {
      "is_primary": true,
      "skill_name": "pgvector"
    },
    {
      "is_primary": true,
      "skill_name": "A/B Testing"
    },
    {
      "is_primary": true,
      "skill_name": "MLflow"
    },
    {
      "is_primary": true,
      "skill_name": "CI/CD"
    },
    {
      "is_primary": false,
      "skill_name": "Pinecone"
    },
    {
      "is_primary": false,
      "skill_name": "Weaviate"
    },
    {
      "is_primary": false,
      "skill_name": "text-embedding-3"
    },
    {
      "is_primary": false,
      "skill_name": "BGE"
    },
    {
      "is_primary": false,
      "skill_name": "vLLM"
    },
    {
      "is_primary": false,
      "skill_name": "TGI"
    },
    {
      "is_primary": false,
      "skill_name": "Triton"
    },
    {
      "is_primary": false,
      "skill_name": "Kubeflow"
    },
    {
      "is_primary": false,
      "skill_name": "Weights \u0026 Biases"
    },
    {
      "is_primary": false,
      "skill_name": "Airflow"
    },
    {
      "is_primary": false,
      "skill_name": "Prefect"
    },
    {
      "is_primary": false,
      "skill_name": "Kubernetes"
    },
    {
      "is_primary": false,
      "skill_name": "GPU scheduling"
    },
    {
      "is_primary": false,
      "skill_name": "BM25"
    },
    {
      "is_primary": false,
      "skill_name": "Quantization"
    },
    {
      "is_primary": false,
      "skill_name": "FP16"
    },
    {
      "is_primary": false,
      "skill_name": "INT8"
    }
  ],
  "jd_role": {
    "display_name": "Senior Machine Learning Engineer",
    "rationale": null,
    "role_aliases": [
      "ML Engineer",
      "Machine Learning Engineer",
      "Senior ML Engineer"
    ],
    "role_archetype": "Data",
    "slug": ""
  },
  "nano_parsed": {
    "JD_type": "pass",
    "about_company": null,
    "certifications": [],
    "company_name": null,
    "ctc": {
      "currency": null,
      "max": null,
      "min": null,
      "period": null,
      "raw": "competitive"
    },
    "domain": {
      "primary": {
        "aliases": [],
        "domain": "Software \u0026 SaaS Products"
      },
      "secondary": null
    },
    "education": [],
    "experience": {
      "max": null,
      "min": 5,
      "raw": "5+ years of hands-on ML engineering experience, with at least 2 years productionising deep-learning models."
    },
    "job_locations": [
      {
        "aliases": [
          "Bangalore"
        ],
        "city": "Bengaluru",
        "country": "India",
        "state": null,
        "work_mode": "hybrid"
      }
    ],
    "role": "Senior Machine Learning Engineer",
    "role_aliases": [
      "ML Engineer",
      "Machine Learning Engineer",
      "Senior ML Engineer"
    ],
    "role_archetype": "Data",
    "roles_and_responsibilities": [
      {
        "bullet_count": 0,
        "heading": "About the role",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "We are looking for a",
          "last_5_words": "infrastructure end-to-end."
        },
        "text": "We are looking for a Senior ML Engineer to own the lifecycle of production machine-learning systems at our platform. You will work with applied scientists to take research models from notebook to production, build retrieval-augmented generation (RAG) pipelines on top of our internal document corpus, and own MLOps infrastructure end-to-end.",
        "word_count": 49
      },
      {
        "bullet_count": 5,
        "heading": "Responsibilities",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "Design and deploy production-grade",
          "last_5_words": "versioning (MLflow), and CI/CD for ML."
        },
        "text": "- Design and deploy production-grade ML services serving 50M+ predictions/day.\n- Build feature stores, training pipelines, and online inference infrastructure with PyTorch and Hugging Face Transformers.\n- Lead our LLM efforts: fine-tune open-source models (Llama 3, Mistral) and integrate with our RAG retrieval layer (FAISS, pgvector embeddings).\n- Set up evaluation harnesses, A/B testing frameworks, and model monitoring/drift detection.\n- Mentor junior ML engineers on best practices for reproducible experiments, model versioning (MLflow), and CI/CD for ML.",
        "word_count": 104
      },
      {
        "bullet_count": 6,
        "heading": "Requirements",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "5+ years of hands-on ML",
          "last_5_words": "experience with GPU scheduling preferred."
        },
        "text": "- 5+ years of hands-on ML engineering experience, with at least 2 years productionising deep-learning models.\n- Strong Python; production code with PyTorch, TensorFlow, or JAX.\n- Experience with vector databases (Pinecone, Weaviate, pgvector) and embedding models (text-embedding-3, BGE, etc.).\n- LLM serving experience: vLLM, TGI, or Triton.\n- Familiar with MLOps tooling (MLflow, Kubeflow, Weights \u0026 Biases) and orchestration (Airflow, Prefect).\n- Comfort with Kubernetes for ML workloads; experience with GPU scheduling preferred.",
        "word_count": 104
      },
      {
        "bullet_count": 3,
        "heading": "Nice to have",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "Open-source contributions to ML",
          "last_5_words": "quantization (INT8/FP16), and inference optimisation."
        },
        "text": "- Open-source contributions to ML frameworks or popular LLM tooling.\n- Experience with retrieval-augmented generation, sparse retrieval (BM25), and hybrid search.\n- Familiarity with vector index tuning, quantization (INT8/FP16), and inference optimisation.",
        "word_count": 45
      }
    ],
    "urls": []
  },
  "rejected": false,
  "rejection_reason": null,
  "run_id": "0aa94386-7f59-430c-b6f7-8f25e5b5c76e",
  "stage3_signals": {
    "alias_found": true,
    "alias_match_roles": [
      {
        "display_name": "ML Engineer",
        "kra_matches": null,
        "matched_count": null,
        "matched_skills": null,
        "role_id": 3,
        "score": 1.0,
        "slug": "ml-engineer",
        "total_count": null
      }
    ],
    "kra_match_roles": [
      {
        "display_name": "ML Ops Engineer",
        "kra_matches": [
          {
            "kra_text": "Maintains model versioning, experiment lineage, and artifact tracking using MLflow, DVC, or Weights \u0026 Biases for reproducibility and auditability.",
            "sentence": "Mentor junior ML engineers on best practices for reproducible experiments, model versioning (MLflow), and CI/CD for ML.",
            "similarity": 0.6578
          },
          {
            "kra_text": "Sets up model monitoring dashboards, data drift detection, prediction performance tracking, and alert routing for production ML systems.",
            "sentence": "Set up evaluation harnesses, A/B testing frameworks, and model monitoring/drift detection.",
            "similarity": 0.6212
          },
          {
            "kra_text": "Sets up model monitoring dashboards, data drift detection, prediction performance tracking, and alert routing for production ML systems.",
            "sentence": "Design and deploy production-grade ML services serving 50M+ predictions/day.",
            "similarity": 0.6049
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 16,
        "score": 0.628,
        "slug": "ml-ops-engineer",
        "total_count": null
      },
      {
        "display_name": "ML Engineer",
        "kra_matches": [
          {
            "kra_text": "Builds model serving infrastructure to deploy trained models as real-time prediction APIs or batch inference jobs using TorchServe, TensorFlow Serving, or SageMaker.",
            "sentence": "Design and deploy production-grade ML services serving 50M+ predictions/day.",
            "similarity": 0.6091
          },
          {
            "kra_text": "Prepares, cleans, and transforms training datasets, manages feature stores, and builds feature engineering pipelines for model training.",
            "sentence": "Build feature stores, training pipelines, and online inference infrastructure with PyTorch and Hugging Face Transformers.",
            "similarity": 0.607
          },
          {
            "kra_text": "Monitors production model behavior for data drift, concept drift, and prediction performance degradation using monitoring dashboards and alerting.",
            "sentence": "Set up evaluation harnesses, A/B testing frameworks, and model monitoring/drift detection.",
            "similarity": 0.5963
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 3,
        "score": 0.6042,
        "slug": "ml-engineer",
        "total_count": null
      },
      {
        "display_name": "AI Engineer",
        "kra_matches": [
          {
            "kra_text": "Defines evaluation frameworks, automated test suites, and human feedback loops to measure AI feature quality, accuracy, and consistency.",
            "sentence": "Set up evaluation harnesses, A/B testing frameworks, and model monitoring/drift detection.",
            "similarity": 0.5699
          },
          {
            "kra_text": "Designs and implements prompt engineering workflows, few-shot examples, chain-of-thought patterns, and structured output parsing for AI feature pipelines.",
            "sentence": "Build feature stores, training pipelines, and online inference infrastructure with PyTorch and Hugging Face Transformers.",
            "similarity": 0.5055
          },
          {
            "kra_text": "Designs and implements prompt engineering workflows, few-shot examples, chain-of-thought patterns, and structured output parsing for AI feature pipelines.",
            "sentence": "You will work with applied scientists to take research models from notebook to production, build retrieval-augmented generation (RAG) pipelines on top of our internal document corpus, and own MLOps infrastructure end-to-end.",
            "similarity": 0.4857
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 13,
        "score": 0.5204,
        "slug": "ai-engineer",
        "total_count": null
      },
      {
        "display_name": "DevOps Engineer",
        "kra_matches": [
          {
            "kra_text": "Collaborates with development teams to improve build processes, reduce deployment friction, containerize applications, and adopt DevOps best practices.",
            "sentence": "Mentor junior ML engineers on best practices for reproducible experiments, model versioning (MLflow), and CI/CD for ML.",
            "similarity": 0.4746
          },
          {
            "kra_text": "Manages container orchestration with Kubernetes and Docker, deploying applications as pods, managing namespaces, and configuring auto-scaling across cloud environments.",
            "sentence": "Comfort with Kubernetes for ML workloads; experience with GPU scheduling preferred.",
            "similarity": 0.459
          },
          {
            "kra_text": "Monitors CI/CD pipeline reliability, identifies bottlenecks in delivery workflows, and improves deployment frequency, lead time, and failure recovery rate.",
            "sentence": "Set up evaluation harnesses, A/B testing frameworks, and model monitoring/drift detection.",
            "similarity": 0.4484
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 10,
        "score": 0.4607,
        "slug": "devops-engineer",
        "total_count": null
      },
      {
        "display_name": "AI Compliance Officer",
        "kra_matches": [
          {
            "kra_text": "Monitors deployed AI systems for compliance policy drift, regulatory changes, and emerging requirements affecting existing AI deployments.",
            "sentence": "Set up evaluation harnesses, A/B testing frameworks, and model monitoring/drift detection.",
            "similarity": 0.5023
          },
          {
            "kra_text": "Reviews AI use cases and model deployments against applicable regulations, internal ethics policies, and governance guidelines prior to production approval.",
            "sentence": "Design and deploy production-grade ML services serving 50M+ predictions/day.",
            "similarity": 0.4208
          },
          {
            "kra_text": "Monitors deployed AI systems for compliance policy drift, regulatory changes, and emerging requirements affecting existing AI deployments.",
            "sentence": "We are looking for a Senior ML Engineer to own the lifecycle of production machine-learning systems at our platform.",
            "similarity": 0.4038
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 12,
        "score": 0.4423,
        "slug": "ai-compliance-officer",
        "total_count": null
      }
    ],
    "skill_match_roles": [
      {
        "display_name": "ML Engineer",
        "kra_matches": null,
        "matched_count": 5,
        "matched_skills": [
          "CI/CD",
          "FAISS",
          "MLflow",
          "PyTorch",
          "Python"
        ],
        "role_id": 3,
        "score": 0.4545,
        "slug": "ml-engineer",
        "total_count": 11
      },
      {
        "display_name": "ML Ops Engineer",
        "kra_matches": null,
        "matched_count": 4,
        "matched_skills": [
          "FAISS",
          "MLflow",
          "PyTorch",
          "Python"
        ],
        "role_id": 16,
        "score": 0.3636,
        "slug": "ml-ops-engineer",
        "total_count": 11
      },
      {
        "display_name": "AI Engineer",
        "kra_matches": null,
        "matched_count": 2,
        "matched_skills": [
          "PyTorch",
          "pgvector"
        ],
        "role_id": 13,
        "score": 0.1818,
        "slug": "ai-engineer",
        "total_count": 11
      },
      {
        "display_name": "AR/VR Engineer",
        "kra_matches": null,
        "matched_count": 1,
        "matched_skills": [
          "Python"
        ],
        "role_id": 8,
        "score": 0.0909,
        "slug": "ar-vr-engineer",
        "total_count": 11
      },
      {
        "display_name": "DevOps Engineer",
        "kra_matches": null,
        "matched_count": 1,
        "matched_skills": [
          "CI/CD"
        ],
        "role_id": 10,
        "score": 0.0909,
        "slug": "devops-engineer",
        "total_count": 11
      }
    ]
  },
  "stage4_decision": {
    "alias_collision_detected": false,
    "case": "A",
    "chosen_role": {
      "display_name": "ML Engineer",
      "kra_matches": null,
      "matched_count": null,
      "matched_skills": null,
      "role_id": 3,
      "score": 1.0,
      "slug": "ml-engineer",
      "total_count": null
    },
    "confidence": 1.0,
    "is_new_role": false,
    "llm2_fired": false,
    "llm2_reasoning": null,
    "matched_dimensions": [],
    "matched_kras": [],
    "matched_skills": [],
    "new_role_display_name": null,
    "new_role_slug": null,
    "queued": false,
    "reasoning": "Exact alias hit on ml-engineer (1.0) \u2014 no other alias at this confidence; skill_top ml-engineer 0.45 does not contradict",
    "sub_role": null
  },
  "stage5_updates": {
    "centroid_n_after": 15,
    "centroid_updated": true,
    "collision_log_id": null,
    "new_kra_attached": null,
    "new_skills_attached": [
      {
        "is_primary": true,
        "queue_id": 3234,
        "role_display_name": "ML Engineer",
        "role_slug": "ml-engineer",
        "skill_name": "Hugging Face Transformers",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 3235,
        "role_display_name": "ML Engineer",
        "role_slug": "ml-engineer",
        "skill_name": "Llama 3",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 3236,
        "role_display_name": "ML Engineer",
        "role_slug": "ml-engineer",
        "skill_name": "Mistral",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 3237,
        "role_display_name": "ML Engineer",
        "role_slug": "ml-engineer",
        "skill_name": "text-embedding-3",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 3238,
        "role_display_name": "ML Engineer",
        "role_slug": "ml-engineer",
        "skill_name": "TGI",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 3239,
        "role_display_name": "ML Engineer",
        "role_slug": "ml-engineer",
        "skill_name": "GPU scheduling",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 3240,
        "role_display_name": "ML Engineer",
        "role_slug": "ml-engineer",
        "skill_name": "BM25",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 3241,
        "role_display_name": "ML Engineer",
        "role_slug": "ml-engineer",
        "skill_name": "FP16",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 3242,
        "role_display_name": "ML Engineer",
        "role_slug": "ml-engineer",
        "skill_name": "INT8",
        "status": "pending"
      }
    ],
    "queue_entry_id": null,
    "v3_pipeline_triggered": false,
    "v3_role_slug": null,
    "v3_run_id": null
  }
}
API 2 — extract-details
{
  "alias_matches": [
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 67,
      "existing_alias_text": "Python",
      "input_term": "Python",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Python",
        "id": 5,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "python",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 441,
      "existing_alias_text": "PyTorch",
      "input_term": "PyTorch",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "PyTorch",
        "id": 195,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "pytorch",
        "sub_category_id": 156,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 442,
      "existing_alias_text": "TensorFlow",
      "input_term": "TensorFlow",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "TensorFlow",
        "id": 196,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "tensorflow",
        "sub_category_id": 156,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 451,
      "existing_alias_text": "JAX",
      "input_term": "JAX",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "JAX",
        "id": 199,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "jax",
        "sub_category_id": 156,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1830,
      "existing_alias_text": "RAG",
      "input_term": "RAG",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "RAG",
        "id": 1194,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "rag",
        "sub_category_id": 904,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1820,
      "existing_alias_text": "FAISS",
      "input_term": "FAISS",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "FAISS",
        "id": 1184,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "faiss",
        "sub_category_id": 894,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1882,
      "existing_alias_text": "pgvector",
      "input_term": "pgvector",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "pgvector",
        "id": 1246,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "pgvector",
        "sub_category_id": 972,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 2565,
      "existing_alias_text": "A/B Testing",
      "input_term": "A/B Testing",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "A/B Testing",
        "id": 1613,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "a-b-testing",
        "sub_category_id": 1214,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 470,
      "existing_alias_text": "MLflow",
      "input_term": "MLflow",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "MLflow",
        "id": 214,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "mlflow",
        "sub_category_id": 1168,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1826,
      "existing_alias_text": "CI/CD",
      "input_term": "CI/CD",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "CI/CD",
        "id": 1190,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "ci-cd",
        "sub_category_id": 900,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 503,
      "existing_alias_text": "Pinecone",
      "input_term": "Pinecone",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "Pinecone",
        "id": 242,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "pinecone",
        "sub_category_id": 177,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1878,
      "existing_alias_text": "Weaviate",
      "input_term": "Weaviate",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "Weaviate",
        "id": 1242,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "weaviate",
        "sub_category_id": 177,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "TODO: REMOVE AFTER TESTING \u2014 alias DB write disabled",
      "alias_persisted": false,
      "existing_alias_id": 1888,
      "existing_alias_text": "text-embedding-3-large",
      "input_term": "text-embedding-3",
      "matched_canonical": {
        "category_id": 11,
        "display_name": "text-embedding-3-large",
        "id": 1252,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "text-embedding-3-large",
        "sub_category_id": 1005,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "embedding_alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1885,
      "existing_alias_text": "BGE",
      "input_term": "BGE",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "BGE",
        "id": 1249,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "bge",
        "sub_category_id": 973,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 502,
      "existing_alias_text": "vLLM",
      "input_term": "vLLM",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "vLLM",
        "id": 241,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "vllm",
        "sub_category_id": 1167,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 2026,
      "existing_alias_text": "Triton",
      "input_term": "Triton",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Triton",
        "id": 1367,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "triton",
        "sub_category_id": 1033,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 465,
      "existing_alias_text": "Kubeflow",
      "input_term": "Kubeflow",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Kubeflow",
        "id": 213,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "kubeflow",
        "sub_category_id": 1127,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 471,
      "existing_alias_text": "Weights \u0026 Biases",
      "input_term": "Weights \u0026 Biases",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "Weights \u0026 Biases",
        "id": 215,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "weights-biases",
        "sub_category_id": 171,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 526,
      "existing_alias_text": "Airflow",
      "input_term": "Airflow",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Airflow",
        "id": 265,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "airflow",
        "sub_category_id": 130,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 306,
      "existing_alias_text": "Prefect",
      "input_term": "Prefect",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Prefect",
        "id": 112,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "prefect",
        "sub_category_id": 130,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1267,
      "existing_alias_text": "Kubernetes",
      "input_term": "Kubernetes",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "Kubernetes",
        "id": 726,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "kubernetes",
        "sub_category_id": 557,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 521,
      "existing_alias_text": "quantization",
      "input_term": "Quantization",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "quantization",
        "id": 260,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "quantization",
        "sub_category_id": 1282,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    }
  ],
  "candidate_roles": [
    {
      "display_name": "Cloud Security Engineer",
      "id": 23,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-security-engineer",
      "source": "db"
    },
    {
      "display_name": "Backend Developer",
      "id": 1,
      "rationale": null,
      "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
      "slug": "backend-engineer",
      "source": "db"
    },
    {
      "display_name": "Fullstack Developer",
      "id": 15,
      "rationale": null,
      "role_archetype": null,
      "slug": "full-stack-engineer",
      "source": "db"
    },
    {
      "display_name": "Cybersecurity Engineer",
      "id": 5,
      "rationale": null,
      "role_archetype": null,
      "slug": "cybersecurity-engineer",
      "source": "db"
    },
    {
      "display_name": "Data Engineer",
      "id": 2,
      "rationale": null,
      "role_archetype": null,
      "slug": "data-engineer",
      "source": "db"
    },
    {
      "display_name": "ML Engineer",
      "id": 3,
      "rationale": null,
      "role_archetype": null,
      "slug": "ml-engineer",
      "source": "db"
    },
    {
      "display_name": "ML Ops Engineer",
      "id": 16,
      "rationale": null,
      "role_archetype": null,
      "slug": "ml-ops-engineer",
      "source": "db"
    },
    {
      "display_name": "AR/VR Engineer",
      "id": 8,
      "rationale": null,
      "role_archetype": null,
      "slug": "ar-vr-engineer",
      "source": "db"
    },
    {
      "display_name": "AI Engineer",
      "id": 13,
      "rationale": null,
      "role_archetype": null,
      "slug": "ai-engineer",
      "source": "db"
    },
    {
      "display_name": "DevOps Engineer",
      "id": 10,
      "rationale": null,
      "role_archetype": null,
      "slug": "devops-engineer",
      "source": "db"
    },
    {
      "display_name": "Cloud Architect",
      "id": 9,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-architect",
      "source": "db"
    },
    {
      "display_name": "Video Codec Engineer",
      "id": 22,
      "rationale": null,
      "role_archetype": null,
      "slug": "video-codec-engineer",
      "source": "db"
    }
  ],
  "chosen_role": {
    "display_name": "Machine Learning Engineer",
    "id": null,
    "rationale": "This role aligns with primary skills like Python, PyTorch, and multiple ML frameworks essential for machine learning tasks.",
    "role_archetype": "An expert who designs and implements machine learning models and systems.",
    "slug": "machine-learning-engineer",
    "source": "llm"
  },
  "dimensions": [
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Security Scripting \u0026 DSL Languages",
        "id": 248,
        "rationale": "Proficiency in programming and domain-specific languages used to automate and script cloud security controls.",
        "slug": "cloud-security-scripting-dsl-languages",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages and Scripting",
        "id": 59,
        "rationale": "Languages used to write security automation, analysis scripts, detection logic, and remediation helpers. This is the primary implementation surface for a cybersecurity engineer across tooling and response workflows.",
        "slug": "programming-languages-and-scripting",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cybersecurity Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for Data Work",
        "id": 21,
        "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
        "slug": "programming-languages-for-data-work",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for ML Systems",
        "id": 39,
        "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
        "slug": "programming-languages-for-ml-systems",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for XR",
        "id": 97,
        "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
        "slug": "programming-languages-for-xr",
        "source": "db"
      },
      "input_skill": "Python",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AR/VR Engineer",
          "id": 8,
          "rationale": null,
          "role_archetype": null,
          "slug": "ar-vr-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "ML Frameworks and Libraries",
        "id": 40,
        "rationale": "Core libraries used to define models, train them, run inference, and evaluate predictive performance. These frameworks shape how ML engineers express model architectures and training loops.",
        "slug": "ml-frameworks-and-libraries",
        "source": "db"
      },
      "input_skill": "PyTorch",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Model Fine-Tuning \u0026 Adaptation",
        "id": 212,
        "rationale": "Techniques and libraries for adapting pre-trained language models to specific tasks or domains.",
        "slug": "model-fine-tuning-adaptation",
        "source": "db"
      },
      "input_skill": "PyTorch",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "ML Frameworks and Libraries",
        "id": 40,
        "rationale": "Core libraries used to define models, train them, run inference, and evaluate predictive performance. These frameworks shape how ML engineers express model architectures and training loops.",
        "slug": "ml-frameworks-and-libraries",
        "source": "db"
      },
      "input_skill": "TensorFlow",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "ML Frameworks and Libraries",
        "id": 40,
        "rationale": "Core libraries used to define models, train them, run inference, and evaluate predictive performance. These frameworks shape how ML engineers express model architectures and training loops.",
        "slug": "ml-frameworks-and-libraries",
        "source": "db"
      },
      "input_skill": "JAX",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "RAG",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "ML Frameworks and Libraries",
        "id": 40,
        "rationale": "Core libraries used to define models, train them, run inference, and evaluate predictive performance. These frameworks shape how ML engineers express model architectures and training loops.",
        "slug": "ml-frameworks-and-libraries",
        "source": "db"
      },
      "input_skill": "FAISS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "FAISS",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Vector Databases",
        "id": 198,
        "rationale": "Specialized storage and indexing systems used to persist embeddings and support similarity search. This is a distinct vendor-family cluster because AI features often depend on a concrete vector store choice and its operational behavior.",
        "slug": "vector-databases",
        "source": "db"
      },
      "input_skill": "pgvector",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "A/B Testing",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Systems Programming",
        "id": 166,
        "rationale": "Systems programming covers low-level software development where performance, memory safety, and direct control over resources matter. Rust fits here because it is commonly used for OS-adjacent services, infrastructure components, and other performance-sensitive systems code.",
        "slug": "d_init_02",
        "source": "db"
      },
      "input_skill": "A/B Testing",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "MLOps Platforms and Lifecycle",
        "id": 43,
        "rationale": "End-to-end managed platforms used to train, deploy, register, and govern models across their lifecycle. This is the operational control plane for production ML workflows.",
        "slug": "mlops-platforms-and-lifecycle",
        "source": "db"
      },
      "input_skill": "MLflow",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "CI/CD",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD for Machine Learning",
        "id": 56,
        "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
        "slug": "ci-cd-for-machine-learning",
        "source": "db"
      },
      "input_skill": "CI/CD",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "LLM Operations and Orchestration",
        "id": 49,
        "rationale": "Operational stack for building, serving, evaluating, and orchestrating LLM-based systems. This includes vector retrieval, prompt workflows, LLM serving, and observability for generative applications.",
        "slug": "llm-operations-and-orchestration",
        "source": "db"
      },
      "input_skill": "Pinecone",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Vector Databases",
        "id": 198,
        "rationale": "Specialized storage and indexing systems used to persist embeddings and support similarity search. This is a distinct vendor-family cluster because AI features often depend on a concrete vector store choice and its operational behavior.",
        "slug": "vector-databases",
        "source": "db"
      },
      "input_skill": "Pinecone",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Vector Databases",
        "id": 198,
        "rationale": "Specialized storage and indexing systems used to persist embeddings and support similarity search. This is a distinct vendor-family cluster because AI features often depend on a concrete vector store choice and its operational behavior.",
        "slug": "vector-databases",
        "source": "db"
      },
      "input_skill": "Weaviate",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Embedding Models",
        "id": 199,
        "rationale": "Models and APIs used to convert text or other content into vector representations for retrieval, clustering, and semantic matching. This cluster is coherent because embedding choice affects retrieval quality, cost, and latency in AI features.",
        "slug": "embedding-models",
        "source": "db"
      },
      "input_skill": "text-embedding-3",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Embedding Models",
        "id": 199,
        "rationale": "Models and APIs used to convert text or other content into vector representations for retrieval, clustering, and semantic matching. This cluster is coherent because embedding choice affects retrieval quality, cost, and latency in AI features.",
        "slug": "embedding-models",
        "source": "db"
      },
      "input_skill": "BGE",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "LLM Operations and Orchestration",
        "id": 49,
        "rationale": "Operational stack for building, serving, evaluating, and orchestrating LLM-based systems. This includes vector retrieval, prompt workflows, LLM serving, and observability for generative applications.",
        "slug": "llm-operations-and-orchestration",
        "source": "db"
      },
      "input_skill": "vLLM",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "LLM Serving \u0026 Deployment",
        "id": 209,
        "rationale": "Tools and frameworks for hosting and serving LLM models in production environments.",
        "slug": "llm-serving-deployment",
        "source": "db"
      },
      "input_skill": "vLLM",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Model Optimization and Acceleration",
        "id": 53,
        "rationale": "Techniques for improving inference latency, throughput, memory use, and training efficiency. ML engineers use these methods to meet production constraints without sacrificing too much quality.",
        "slug": "model-optimization-and-acceleration",
        "source": "db"
      },
      "input_skill": "Triton",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "MLOps Platforms and Lifecycle",
        "id": 43,
        "rationale": "End-to-end managed platforms used to train, deploy, register, and govern models across their lifecycle. This is the operational control plane for production ML workflows.",
        "slug": "mlops-platforms-and-lifecycle",
        "source": "db"
      },
      "input_skill": "Kubeflow",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Experiment Tracking and Evaluation",
        "id": 44,
        "rationale": "Tools and practices for recording experiments, comparing runs, and assessing model quality before release. This dimension focuses on reproducibility, metrics, artifacts, and offline evaluation workflows.",
        "slug": "experiment-tracking-and-evaluation",
        "source": "db"
      },
      "input_skill": "Weights \u0026 Biases",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Workflow Orchestration for ML Pipelines",
        "id": 54,
        "rationale": "Workflow engines used to coordinate training, evaluation, deployment, and retraining jobs. This cluster covers dependencies, retries, scheduling, and pipeline composition for ML lifecycle automation.",
        "slug": "workflow-orchestration-for-ml-pipelines",
        "source": "db"
      },
      "input_skill": "Airflow",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Data Pipeline Orchestration",
        "id": 23,
        "rationale": "Workflow engines that schedule, coordinate, and recover batch data jobs. This cluster covers dependency management, retries, backfills, sensors, and operational control of pipeline DAGs.",
        "slug": "data-pipeline-orchestration",
        "source": "db"
      },
      "input_skill": "Prefect",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Workflow Orchestration for ML Pipelines",
        "id": 54,
        "rationale": "Workflow engines used to coordinate training, evaluation, deployment, and retraining jobs. This cluster covers dependencies, retries, scheduling, and pipeline composition for ML lifecycle automation.",
        "slug": "workflow-orchestration-for-ml-pipelines",
        "source": "db"
      },
      "input_skill": "Prefect",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Container Orchestration Platforms",
        "id": 134,
        "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
        "slug": "container-orchestration-platforms",
        "source": "db"
      },
      "input_skill": "Kubernetes",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Kubernetes for ML Workloads",
        "id": 47,
        "rationale": "Kubernetes-native components used to schedule, accelerate, and isolate ML training and serving workloads. This includes GPU enablement and ML-specific controllers rather than generic cluster administration.",
        "slug": "kubernetes-for-ml-workloads",
        "source": "db"
      },
      "input_skill": "Kubernetes",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Model Optimization and Acceleration",
        "id": 53,
        "rationale": "Techniques for improving inference latency, throughput, memory use, and training efficiency. ML engineers use these methods to meet production constraints without sacrificing too much quality.",
        "slug": "model-optimization-and-acceleration",
        "source": "db"
      },
      "input_skill": "Quantization",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Video Compression Algorithms",
        "id": 226,
        "rationale": "Core compression and decompression techniques that determine bitrate, quality, and decode cost. This cluster covers the algorithmic heart of codec engineering.",
        "slug": "video-compression-algorithms",
        "source": "db"
      },
      "input_skill": "Quantization",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Video Codec Engineer",
          "id": 22,
          "rationale": null,
          "role_archetype": null,
          "slug": "video-codec-engineer",
          "source": "db"
        }
      ]
    }
  ],
  "input_final_skills": [
    "Python",
    "PyTorch",
    "TensorFlow",
    "JAX",
    "Hugging Face Transformers",
    "Llama 3",
    "Mistral",
    "RAG",
    "FAISS",
    "pgvector",
    "A/B Testing",
    "MLflow",
    "CI/CD",
    "Pinecone",
    "Weaviate",
    "text-embedding-3",
    "BGE",
    "vLLM",
    "TGI",
    "Triton",
    "Kubeflow",
    "Weights \u0026 Biases",
    "Airflow",
    "Prefect",
    "Kubernetes",
    "GPU scheduling",
    "BM25",
    "Quantization",
    "FP16",
    "INT8"
  ],
  "input_llm_skills": [
    "Python",
    "PyTorch",
    "TensorFlow",
    "JAX",
    "Hugging Face Transformers",
    "Llama 3",
    "Mistral",
    "RAG",
    "FAISS",
    "pgvector",
    "A/B Testing",
    "MLflow",
    "CI/CD",
    "Pinecone",
    "Weaviate",
    "text-embedding-3",
    "BGE",
    "vLLM",
    "TGI",
    "Triton",
    "Kubeflow",
    "Weights \u0026 Biases",
    "Airflow",
    "Prefect",
    "Kubernetes",
    "GPU scheduling",
    "BM25",
    "Quantization",
    "FP16",
    "INT8"
  ],
  "new_aliases_persisted": 0,
  "run_id": "0aa94386-7f59-430c-b6f7-8f25e5b5c76e",
  "skills_detail": [
    {
      "aliases_in_db": [
        {
          "alias_text": "Python",
          "alias_type": "CANONICAL",
          "id": 67,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 2",
          "alias_type": "VERSION",
          "id": 72,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 2.x",
          "alias_type": "VERSION",
          "id": 74,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3",
          "alias_type": "VERSION",
          "id": 73,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.10",
          "alias_type": "VERSION",
          "id": 76,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.11",
          "alias_type": "VERSION",
          "id": 77,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.12",
          "alias_type": "VERSION",
          "id": 78,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Python 3.x",
          "alias_type": "VERSION",
          "id": 75,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py",
          "alias_type": "VERSION",
          "id": 2183,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py2",
          "alias_type": "VERSION",
          "id": 68,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "py3",
          "alias_type": "VERSION",
          "id": 69,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 3",
          "alias_type": "VERSION",
          "id": 2186,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python 3.x",
          "alias_type": "VERSION",
          "id": 2849,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python2",
          "alias_type": "VERSION",
          "id": 70,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python3",
          "alias_type": "VERSION",
          "id": 71,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "python3.x",
          "alias_type": "VERSION",
          "id": 2848,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Python",
        "id": 5,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "python",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Security Scripting \u0026 DSL Languages",
            "id": 248,
            "rationale": "Proficiency in programming and domain-specific languages used to automate and script cloud security controls.",
            "slug": "cloud-security-scripting-dsl-languages",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages and Scripting",
            "id": 59,
            "rationale": "Languages used to write security automation, analysis scripts, detection logic, and remediation helpers. This is the primary implementation surface for a cybersecurity engineer across tooling and response workflows.",
            "slug": "programming-languages-and-scripting",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cybersecurity Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for Data Work",
            "id": 21,
            "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
            "slug": "programming-languages-for-data-work",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for ML Systems",
            "id": 39,
            "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
            "slug": "programming-languages-for-ml-systems",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for XR",
            "id": 97,
            "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
            "slug": "programming-languages-for-xr",
            "source": "db"
          },
          "input_skill": "Python",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AR/VR Engineer",
              "id": 8,
              "rationale": null,
              "role_archetype": null,
              "slug": "ar-vr-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Python",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "PyTorch",
          "alias_type": "CANONICAL",
          "id": 441,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "PyTorch",
        "id": 195,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "pytorch",
        "sub_category_id": 156,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "ML Frameworks and Libraries",
            "id": 40,
            "rationale": "Core libraries used to define models, train them, run inference, and evaluate predictive performance. These frameworks shape how ML engineers express model architectures and training loops.",
            "slug": "ml-frameworks-and-libraries",
            "source": "db"
          },
          "input_skill": "PyTorch",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Model Fine-Tuning \u0026 Adaptation",
            "id": 212,
            "rationale": "Techniques and libraries for adapting pre-trained language models to specific tasks or domains.",
            "slug": "model-fine-tuning-adaptation",
            "source": "db"
          },
          "input_skill": "PyTorch",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "PyTorch",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "TensorFlow",
          "alias_type": "CANONICAL",
          "id": 442,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TF1",
          "alias_type": "VERSION",
          "id": 443,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TF2",
          "alias_type": "VERSION",
          "id": 444,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TensorFlow 1",
          "alias_type": "VERSION",
          "id": 445,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TensorFlow 1.x",
          "alias_type": "VERSION",
          "id": 447,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TensorFlow 2",
          "alias_type": "VERSION",
          "id": 446,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TensorFlow 2.x",
          "alias_type": "VERSION",
          "id": 448,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "tensorflow 1",
          "alias_type": "VERSION",
          "id": 2490,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "tensorflow 1.x",
          "alias_type": "VERSION",
          "id": 2494,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "tensorflow 2",
          "alias_type": "VERSION",
          "id": 2491,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "tensorflow 2.x",
          "alias_type": "VERSION",
          "id": 2495,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "tensorflow v1",
          "alias_type": "VERSION",
          "id": 2492,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "tensorflow v2",
          "alias_type": "VERSION",
          "id": 2493,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "tf",
          "alias_type": "VERSION",
          "id": 2487,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "tf1",
          "alias_type": "VERSION",
          "id": 2488,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "tf2",
          "alias_type": "VERSION",
          "id": 2489,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "TensorFlow",
        "id": 196,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "tensorflow",
        "sub_category_id": 156,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "ML Frameworks and Libraries",
            "id": 40,
            "rationale": "Core libraries used to define models, train them, run inference, and evaluate predictive performance. These frameworks shape how ML engineers express model architectures and training loops.",
            "slug": "ml-frameworks-and-libraries",
            "source": "db"
          },
          "input_skill": "TensorFlow",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "TensorFlow",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "JAX",
          "alias_type": "CANONICAL",
          "id": 451,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "JAX",
        "id": 199,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "jax",
        "sub_category_id": 156,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "ML Frameworks and Libraries",
            "id": 40,
            "rationale": "Core libraries used to define models, train them, run inference, and evaluate predictive performance. These frameworks shape how ML engineers express model architectures and training loops.",
            "slug": "ml-frameworks-and-libraries",
            "source": "db"
          },
          "input_skill": "JAX",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "JAX",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Hugging Face Transformers",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Machine Learning Frameworks",
          "skill_nature": "TOOL",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "hugging-face-transformers",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Llama 3",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Machine Learning Frameworks",
          "skill_nature": "TOOL",
          "sub_category": "general",
          "typical_lifespan": "SHORT_LIVED",
          "version_strategy": "VERSIONED",
          "volatility": "FAST"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "llama-3",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Mistral",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Machine Learning Frameworks",
          "skill_nature": "TOOL",
          "sub_category": "general",
          "typical_lifespan": "SHORT_LIVED",
          "version_strategy": "VERSIONED",
          "volatility": "FAST"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "mistral",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "RAG",
          "alias_type": "CANONICAL",
          "id": 1830,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "RAG",
        "id": 1194,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "rag",
        "sub_category_id": 904,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "RAG",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "RAG",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "FAISS",
          "alias_type": "CANONICAL",
          "id": 1820,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "FAISS",
        "id": 1184,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "faiss",
        "sub_category_id": 894,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "ML Frameworks and Libraries",
            "id": 40,
            "rationale": "Core libraries used to define models, train them, run inference, and evaluate predictive performance. These frameworks shape how ML engineers express model architectures and training loops.",
            "slug": "ml-frameworks-and-libraries",
            "source": "db"
          },
          "input_skill": "FAISS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "FAISS",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "FAISS",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "pgvector",
          "alias_type": "CANONICAL",
          "id": 1882,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "pgvector",
        "id": 1246,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "pgvector",
        "sub_category_id": 972,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Vector Databases",
            "id": 198,
            "rationale": "Specialized storage and indexing systems used to persist embeddings and support similarity search. This is a distinct vendor-family cluster because AI features often depend on a concrete vector store choice and its operational behavior.",
            "slug": "vector-databases",
            "source": "db"
          },
          "input_skill": "pgvector",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "pgvector",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "A/B Testing",
          "alias_type": "CANONICAL",
          "id": 2565,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "A/B Testing",
        "id": 1613,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "a-b-testing",
        "sub_category_id": 1214,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "A/B Testing",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Systems Programming",
            "id": 166,
            "rationale": "Systems programming covers low-level software development where performance, memory safety, and direct control over resources matter. Rust fits here because it is commonly used for OS-adjacent services, infrastructure components, and other performance-sensitive systems code.",
            "slug": "d_init_02",
            "source": "db"
          },
          "input_skill": "A/B Testing",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "A/B Testing",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "MLflow",
          "alias_type": "CANONICAL",
          "id": 470,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "MLflow",
        "id": 214,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "mlflow",
        "sub_category_id": 1168,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "MLOps Platforms and Lifecycle",
            "id": 43,
            "rationale": "End-to-end managed platforms used to train, deploy, register, and govern models across their lifecycle. This is the operational control plane for production ML workflows.",
            "slug": "mlops-platforms-and-lifecycle",
            "source": "db"
          },
          "input_skill": "MLflow",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "MLflow",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "CI/CD",
          "alias_type": "CANONICAL",
          "id": 1826,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "CI/CD",
        "id": 1190,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "ci-cd",
        "sub_category_id": 900,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "CI/CD",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD for Machine Learning",
            "id": 56,
            "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
            "slug": "ci-cd-for-machine-learning",
            "source": "db"
          },
          "input_skill": "CI/CD",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "CI/CD",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Pinecone",
          "alias_type": "CANONICAL",
          "id": 503,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "Pinecone",
        "id": 242,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "pinecone",
        "sub_category_id": 177,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "LLM Operations and Orchestration",
            "id": 49,
            "rationale": "Operational stack for building, serving, evaluating, and orchestrating LLM-based systems. This includes vector retrieval, prompt workflows, LLM serving, and observability for generative applications.",
            "slug": "llm-operations-and-orchestration",
            "source": "db"
          },
          "input_skill": "Pinecone",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Vector Databases",
            "id": 198,
            "rationale": "Specialized storage and indexing systems used to persist embeddings and support similarity search. This is a distinct vendor-family cluster because AI features often depend on a concrete vector store choice and its operational behavior.",
            "slug": "vector-databases",
            "source": "db"
          },
          "input_skill": "Pinecone",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Pinecone",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Weaviate",
          "alias_type": "CANONICAL",
          "id": 1878,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "Weaviate",
        "id": 1242,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "weaviate",
        "sub_category_id": 177,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Vector Databases",
            "id": 198,
            "rationale": "Specialized storage and indexing systems used to persist embeddings and support similarity search. This is a distinct vendor-family cluster because AI features often depend on a concrete vector store choice and its operational behavior.",
            "slug": "vector-databases",
            "source": "db"
          },
          "input_skill": "Weaviate",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Weaviate",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "text-embedding-3-large",
          "alias_type": "CANONICAL",
          "id": 1888,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 11,
        "display_name": "text-embedding-3-large",
        "id": 1252,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "text-embedding-3-large",
        "sub_category_id": 1005,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Embedding Models",
            "id": 199,
            "rationale": "Models and APIs used to convert text or other content into vector representations for retrieval, clustering, and semantic matching. This cluster is coherent because embedding choice affects retrieval quality, cost, and latency in AI features.",
            "slug": "embedding-models",
            "source": "db"
          },
          "input_skill": "text-embedding-3",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "text-embedding-3",
      "matched_via": "embedding_alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "BGE",
          "alias_type": "CANONICAL",
          "id": 1885,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "BGE",
        "id": 1249,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "bge",
        "sub_category_id": 973,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Embedding Models",
            "id": 199,
            "rationale": "Models and APIs used to convert text or other content into vector representations for retrieval, clustering, and semantic matching. This cluster is coherent because embedding choice affects retrieval quality, cost, and latency in AI features.",
            "slug": "embedding-models",
            "source": "db"
          },
          "input_skill": "BGE",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "BGE",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "vLLM",
          "alias_type": "CANONICAL",
          "id": 502,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "vLLM",
        "id": 241,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "vllm",
        "sub_category_id": 1167,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "LLM Operations and Orchestration",
            "id": 49,
            "rationale": "Operational stack for building, serving, evaluating, and orchestrating LLM-based systems. This includes vector retrieval, prompt workflows, LLM serving, and observability for generative applications.",
            "slug": "llm-operations-and-orchestration",
            "source": "db"
          },
          "input_skill": "vLLM",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "LLM Serving \u0026 Deployment",
            "id": 209,
            "rationale": "Tools and frameworks for hosting and serving LLM models in production environments.",
            "slug": "llm-serving-deployment",
            "source": "db"
          },
          "input_skill": "vLLM",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "vLLM",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "TGI",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Machine Learning Frameworks",
          "skill_nature": "TOOL",
          "sub_category": "general",
          "typical_lifespan": "SHORT_LIVED",
          "version_strategy": "VERSIONED",
          "volatility": "FAST"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "tgi",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Triton",
          "alias_type": "CANONICAL",
          "id": 2026,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Triton",
        "id": 1367,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "triton",
        "sub_category_id": 1033,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Model Optimization and Acceleration",
            "id": 53,
            "rationale": "Techniques for improving inference latency, throughput, memory use, and training efficiency. ML engineers use these methods to meet production constraints without sacrificing too much quality.",
            "slug": "model-optimization-and-acceleration",
            "source": "db"
          },
          "input_skill": "Triton",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Triton",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Kubeflow",
          "alias_type": "CANONICAL",
          "id": 465,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Kubeflow 1.x",
          "alias_type": "VERSION",
          "id": 468,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Kubeflow 2.x",
          "alias_type": "VERSION",
          "id": 469,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Kubeflow v1",
          "alias_type": "VERSION",
          "id": 466,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Kubeflow v2",
          "alias_type": "VERSION",
          "id": 467,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Kubeflow",
        "id": 213,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "kubeflow",
        "sub_category_id": 1127,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "MLOps Platforms and Lifecycle",
            "id": 43,
            "rationale": "End-to-end managed platforms used to train, deploy, register, and govern models across their lifecycle. This is the operational control plane for production ML workflows.",
            "slug": "mlops-platforms-and-lifecycle",
            "source": "db"
          },
          "input_skill": "Kubeflow",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Kubeflow",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Weights \u0026 Biases",
          "alias_type": "CANONICAL",
          "id": 471,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "Weights \u0026 Biases",
        "id": 215,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "weights-biases",
        "sub_category_id": 171,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Experiment Tracking and Evaluation",
            "id": 44,
            "rationale": "Tools and practices for recording experiments, comparing runs, and assessing model quality before release. This dimension focuses on reproducibility, metrics, artifacts, and offline evaluation workflows.",
            "slug": "experiment-tracking-and-evaluation",
            "source": "db"
          },
          "input_skill": "Weights \u0026 Biases",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Weights \u0026 Biases",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Airflow",
          "alias_type": "CANONICAL",
          "id": 526,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "airflow 2",
          "alias_type": "VERSION",
          "id": 2477,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "airflow-2",
          "alias_type": "VERSION",
          "id": 2478,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "airflow2",
          "alias_type": "VERSION",
          "id": 2476,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "airflow2.x",
          "alias_type": "VERSION",
          "id": 2479,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "apache airflow 2",
          "alias_type": "VERSION",
          "id": 2480,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Airflow",
        "id": 265,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "airflow",
        "sub_category_id": 130,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Workflow Orchestration for ML Pipelines",
            "id": 54,
            "rationale": "Workflow engines used to coordinate training, evaluation, deployment, and retraining jobs. This cluster covers dependencies, retries, scheduling, and pipeline composition for ML lifecycle automation.",
            "slug": "workflow-orchestration-for-ml-pipelines",
            "source": "db"
          },
          "input_skill": "Airflow",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Airflow",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Prefect",
          "alias_type": "CANONICAL",
          "id": 306,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Prefect",
        "id": 112,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "prefect",
        "sub_category_id": 130,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Data Pipeline Orchestration",
            "id": 23,
            "rationale": "Workflow engines that schedule, coordinate, and recover batch data jobs. This cluster covers dependency management, retries, backfills, sensors, and operational control of pipeline DAGs.",
            "slug": "data-pipeline-orchestration",
            "source": "db"
          },
          "input_skill": "Prefect",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Workflow Orchestration for ML Pipelines",
            "id": 54,
            "rationale": "Workflow engines used to coordinate training, evaluation, deployment, and retraining jobs. This cluster covers dependencies, retries, scheduling, and pipeline composition for ML lifecycle automation.",
            "slug": "workflow-orchestration-for-ml-pipelines",
            "source": "db"
          },
          "input_skill": "Prefect",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Prefect",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Kubernetes",
          "alias_type": "CANONICAL",
          "id": 1267,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Kubernetes 1.0+",
          "alias_type": "VERSION",
          "id": 1271,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Kubernetes 1.x",
          "alias_type": "VERSION",
          "id": 1270,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Kubernetes v1",
          "alias_type": "VERSION",
          "id": 1269,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "k8s",
          "alias_type": "VERSION",
          "id": 1268,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kubernetes 1.x",
          "alias_type": "VERSION",
          "id": 1400,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kubernetes latest",
          "alias_type": "VERSION",
          "id": 1401,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "Kubernetes",
        "id": 726,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "kubernetes",
        "sub_category_id": 557,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Container Orchestration Platforms",
            "id": 134,
            "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
            "slug": "container-orchestration-platforms",
            "source": "db"
          },
          "input_skill": "Kubernetes",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Kubernetes for ML Workloads",
            "id": 47,
            "rationale": "Kubernetes-native components used to schedule, accelerate, and isolate ML training and serving workloads. This includes GPU enablement and ML-specific controllers rather than generic cluster administration.",
            "slug": "kubernetes-for-ml-workloads",
            "source": "db"
          },
          "input_skill": "Kubernetes",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Kubernetes",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "GPU scheduling",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Infrastructure Tools",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "gpu-scheduling",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "BM25",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Information Retrieval",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "UNVERSIONED",
          "volatility": "STABLE"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "bm25",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "quantization",
          "alias_type": "CANONICAL",
          "id": 521,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "quantization",
        "id": 260,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "quantization",
        "sub_category_id": 1282,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Model Optimization and Acceleration",
            "id": 53,
            "rationale": "Techniques for improving inference latency, throughput, memory use, and training efficiency. ML engineers use these methods to meet production constraints without sacrificing too much quality.",
            "slug": "model-optimization-and-acceleration",
            "source": "db"
          },
          "input_skill": "Quantization",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Video Compression Algorithms",
            "id": 226,
            "rationale": "Core compression and decompression techniques that determine bitrate, quality, and decode cost. This cluster covers the algorithmic heart of codec engineering.",
            "slug": "video-compression-algorithms",
            "source": "db"
          },
          "input_skill": "Quantization",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Video Codec Engineer",
              "id": 22,
              "rationale": null,
              "role_archetype": null,
              "slug": "video-codec-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Quantization",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "FP16",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Machine Learning Frameworks",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "SHORT_LIVED",
          "version_strategy": "VERSIONED",
          "volatility": "FAST"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "fp16",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "INT8",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Machine Learning Frameworks",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "SHORT_LIVED",
          "version_strategy": "VERSIONED",
          "volatility": "FAST"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "int8",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    }
  ],
  "unmatched_skills": [
    "Hugging Face Transformers",
    "Llama 3",
    "Mistral",
    "TGI",
    "GPU scheduling",
    "BM25",
    "FP16",
    "INT8"
  ]
}
API 3 — final-role-output
{
  "chosen_role": {
    "display_name": "ML Engineer",
    "id": 3,
    "rationale": "This role aligns with primary skills like Python, PyTorch, and multiple ML frameworks essential for machine learning tasks.",
    "role_archetype": "An expert who designs and implements machine learning models and systems.",
    "slug": "ml-engineer",
    "source": "db"
  },
  "chosen_role_resolution": "in_db",
  "final_input_skills": [
    {
      "skill": "Python",
      "tag": "in_db"
    },
    {
      "skill": "PyTorch",
      "tag": "in_db"
    },
    {
      "skill": "TensorFlow",
      "tag": "in_db"
    },
    {
      "skill": "JAX",
      "tag": "in_db"
    },
    {
      "skill": "Hugging Face Transformers",
      "tag": "new"
    },
    {
      "skill": "Llama 3",
      "tag": "new"
    },
    {
      "skill": "Mistral",
      "tag": "new"
    },
    {
      "skill": "RAG",
      "tag": "in_db"
    },
    {
      "skill": "FAISS",
      "tag": "in_db"
    },
    {
      "skill": "pgvector",
      "tag": "in_db"
    },
    {
      "skill": "A/B Testing",
      "tag": "in_db"
    },
    {
      "skill": "MLflow",
      "tag": "in_db"
    },
    {
      "skill": "CI/CD",
      "tag": "in_db"
    },
    {
      "skill": "Pinecone",
      "tag": "in_db"
    },
    {
      "skill": "Weaviate",
      "tag": "in_db"
    },
    {
      "skill": "text-embedding-3",
      "tag": "in_db"
    },
    {
      "skill": "BGE",
      "tag": "in_db"
    },
    {
      "skill": "vLLM",
      "tag": "in_db"
    },
    {
      "skill": "TGI",
      "tag": "new"
    },
    {
      "skill": "Triton",
      "tag": "in_db"
    },
    {
      "skill": "Kubeflow",
      "tag": "in_db"
    },
    {
      "skill": "Weights \u0026 Biases",
      "tag": "in_db"
    },
    {
      "skill": "Airflow",
      "tag": "in_db"
    },
    {
      "skill": "Prefect",
      "tag": "in_db"
    },
    {
      "skill": "Kubernetes",
      "tag": "in_db"
    },
    {
      "skill": "GPU scheduling",
      "tag": "new"
    },
    {
      "skill": "BM25",
      "tag": "new"
    },
    {
      "skill": "Quantization",
      "tag": "in_db"
    },
    {
      "skill": "FP16",
      "tag": "new"
    },
    {
      "skill": "INT8",
      "tag": "new"
    }
  ],
  "llm_cost_api1_usd": null,
  "llm_cost_api2_usd": null,
  "llm_cost_api3_usd": null,
  "llm_cost_total_usd": null,
  "persistence": {
    "items": [
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Security Scripting \u0026 DSL Languages",
          "id": 248,
          "rationale": "Proficiency in programming and domain-specific languages used to automate and script cloud security controls.",
          "slug": "cloud-security-scripting-dsl-languages",
          "source": "db"
        },
        "dimension_id": 248,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Security Engineer",
            "id": 23,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-security-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages and Scripting",
          "id": 59,
          "rationale": "Languages used to write security automation, analysis scripts, detection logic, and remediation helpers. This is the primary implementation surface for a cybersecurity engineer across tooling and response workflows.",
          "slug": "programming-languages-and-scripting",
          "source": "db"
        },
        "dimension_id": 59,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cybersecurity Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for Data Work",
          "id": 21,
          "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
          "slug": "programming-languages-for-data-work",
          "source": "db"
        },
        "dimension_id": 21,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Data Engineer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for ML Systems",
          "id": 39,
          "rationale": "Languages used to build training code, inference services, evaluation jobs, and ML glue code. This is the primary implementation surface for ML engineers across experimentation and productionization.",
          "slug": "programming-languages-for-ml-systems",
          "source": "db"
        },
        "dimension_id": 39,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Ops Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for XR",
          "id": 97,
          "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
          "slug": "programming-languages-for-xr",
          "source": "db"
        },
        "dimension_id": 97,
        "input_skill": "Python",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AR/VR Engineer",
            "id": 8,
            "rationale": null,
            "role_archetype": null,
            "slug": "ar-vr-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 5,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "ML Frameworks and Libraries",
          "id": 40,
          "rationale": "Core libraries used to define models, train them, run inference, and evaluate predictive performance. These frameworks shape how ML engineers express model architectures and training loops.",
          "slug": "ml-frameworks-and-libraries",
          "source": "db"
        },
        "dimension_id": 40,
        "input_skill": "PyTorch",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Ops Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 195,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Model Fine-Tuning \u0026 Adaptation",
          "id": 212,
          "rationale": "Techniques and libraries for adapting pre-trained language models to specific tasks or domains.",
          "slug": "model-fine-tuning-adaptation",
          "source": "db"
        },
        "dimension_id": 212,
        "input_skill": "PyTorch",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 13,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 195,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "ML Frameworks and Libraries",
          "id": 40,
          "rationale": "Core libraries used to define models, train them, run inference, and evaluate predictive performance. These frameworks shape how ML engineers express model architectures and training loops.",
          "slug": "ml-frameworks-and-libraries",
          "source": "db"
        },
        "dimension_id": 40,
        "input_skill": "TensorFlow",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Ops Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 196,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "ML Frameworks and Libraries",
          "id": 40,
          "rationale": "Core libraries used to define models, train them, run inference, and evaluate predictive performance. These frameworks shape how ML engineers express model architectures and training loops.",
          "slug": "ml-frameworks-and-libraries",
          "source": "db"
        },
        "dimension_id": 40,
        "input_skill": "JAX",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Ops Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 199,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "RAG",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 1194,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "ML Frameworks and Libraries",
          "id": 40,
          "rationale": "Core libraries used to define models, train them, run inference, and evaluate predictive performance. These frameworks shape how ML engineers express model architectures and training loops.",
          "slug": "ml-frameworks-and-libraries",
          "source": "db"
        },
        "dimension_id": 40,
        "input_skill": "FAISS",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Ops Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1184,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "FAISS",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 1184,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Vector Databases",
          "id": 198,
          "rationale": "Specialized storage and indexing systems used to persist embeddings and support similarity search. This is a distinct vendor-family cluster because AI features often depend on a concrete vector store choice and its operational behavior.",
          "slug": "vector-databases",
          "source": "db"
        },
        "dimension_id": 198,
        "input_skill": "pgvector",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 13,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1246,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "A/B Testing",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 1613,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Systems Programming",
          "id": 166,
          "rationale": "Systems programming covers low-level software development where performance, memory safety, and direct control over resources matter. Rust fits here because it is commonly used for OS-adjacent services, infrastructure components, and other performance-sensitive systems code.",
          "slug": "d_init_02",
          "source": "db"
        },
        "dimension_id": 166,
        "input_skill": "A/B Testing",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 1613,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "MLOps Platforms and Lifecycle",
          "id": 43,
          "rationale": "End-to-end managed platforms used to train, deploy, register, and govern models across their lifecycle. This is the operational control plane for production ML workflows.",
          "slug": "mlops-platforms-and-lifecycle",
          "source": "db"
        },
        "dimension_id": 43,
        "input_skill": "MLflow",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Ops Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 214,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD Pipeline Platforms",
          "id": 150,
          "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
          "slug": "ci-cd-pipeline-platforms",
          "source": "db"
        },
        "dimension_id": 150,
        "input_skill": "CI/CD",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1190,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD for Machine Learning",
          "id": 56,
          "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
          "slug": "ci-cd-for-machine-learning",
          "source": "db"
        },
        "dimension_id": 56,
        "input_skill": "CI/CD",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1190,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "LLM Operations and Orchestration",
          "id": 49,
          "rationale": "Operational stack for building, serving, evaluating, and orchestrating LLM-based systems. This includes vector retrieval, prompt workflows, LLM serving, and observability for generative applications.",
          "slug": "llm-operations-and-orchestration",
          "source": "db"
        },
        "dimension_id": 49,
        "input_skill": "Pinecone",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 13,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Ops Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 242,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Vector Databases",
          "id": 198,
          "rationale": "Specialized storage and indexing systems used to persist embeddings and support similarity search. This is a distinct vendor-family cluster because AI features often depend on a concrete vector store choice and its operational behavior.",
          "slug": "vector-databases",
          "source": "db"
        },
        "dimension_id": 198,
        "input_skill": "Pinecone",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 13,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 242,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Vector Databases",
          "id": 198,
          "rationale": "Specialized storage and indexing systems used to persist embeddings and support similarity search. This is a distinct vendor-family cluster because AI features often depend on a concrete vector store choice and its operational behavior.",
          "slug": "vector-databases",
          "source": "db"
        },
        "dimension_id": 198,
        "input_skill": "Weaviate",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 13,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1242,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Embedding Models",
          "id": 199,
          "rationale": "Models and APIs used to convert text or other content into vector representations for retrieval, clustering, and semantic matching. This cluster is coherent because embedding choice affects retrieval quality, cost, and latency in AI features.",
          "slug": "embedding-models",
          "source": "db"
        },
        "dimension_id": 199,
        "input_skill": "text-embedding-3",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Skipped \u2014 no persistable v3 meta for new skill",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 13,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": false,
        "skill_id": null,
        "skill_tag": "new",
        "skipped_reason": "skill_not_in_db_v3_proposed"
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Embedding Models",
          "id": 199,
          "rationale": "Models and APIs used to convert text or other content into vector representations for retrieval, clustering, and semantic matching. This cluster is coherent because embedding choice affects retrieval quality, cost, and latency in AI features.",
          "slug": "embedding-models",
          "source": "db"
        },
        "dimension_id": 199,
        "input_skill": "BGE",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 13,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1249,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "LLM Operations and Orchestration",
          "id": 49,
          "rationale": "Operational stack for building, serving, evaluating, and orchestrating LLM-based systems. This includes vector retrieval, prompt workflows, LLM serving, and observability for generative applications.",
          "slug": "llm-operations-and-orchestration",
          "source": "db"
        },
        "dimension_id": 49,
        "input_skill": "vLLM",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 13,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Ops Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 241,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "LLM Serving \u0026 Deployment",
          "id": 209,
          "rationale": "Tools and frameworks for hosting and serving LLM models in production environments.",
          "slug": "llm-serving-deployment",
          "source": "db"
        },
        "dimension_id": 209,
        "input_skill": "vLLM",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 13,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 241,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Model Optimization and Acceleration",
          "id": 53,
          "rationale": "Techniques for improving inference latency, throughput, memory use, and training efficiency. ML engineers use these methods to meet production constraints without sacrificing too much quality.",
          "slug": "model-optimization-and-acceleration",
          "source": "db"
        },
        "dimension_id": 53,
        "input_skill": "Triton",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1367,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "MLOps Platforms and Lifecycle",
          "id": 43,
          "rationale": "End-to-end managed platforms used to train, deploy, register, and govern models across their lifecycle. This is the operational control plane for production ML workflows.",
          "slug": "mlops-platforms-and-lifecycle",
          "source": "db"
        },
        "dimension_id": 43,
        "input_skill": "Kubeflow",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Ops Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 213,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Experiment Tracking and Evaluation",
          "id": 44,
          "rationale": "Tools and practices for recording experiments, comparing runs, and assessing model quality before release. This dimension focuses on reproducibility, metrics, artifacts, and offline evaluation workflows.",
          "slug": "experiment-tracking-and-evaluation",
          "source": "db"
        },
        "dimension_id": 44,
        "input_skill": "Weights \u0026 Biases",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Ops Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 215,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Workflow Orchestration for ML Pipelines",
          "id": 54,
          "rationale": "Workflow engines used to coordinate training, evaluation, deployment, and retraining jobs. This cluster covers dependencies, retries, scheduling, and pipeline composition for ML lifecycle automation.",
          "slug": "workflow-orchestration-for-ml-pipelines",
          "source": "db"
        },
        "dimension_id": 54,
        "input_skill": "Airflow",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Ops Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 265,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Data Pipeline Orchestration",
          "id": 23,
          "rationale": "Workflow engines that schedule, coordinate, and recover batch data jobs. This cluster covers dependency management, retries, backfills, sensors, and operational control of pipeline DAGs.",
          "slug": "data-pipeline-orchestration",
          "source": "db"
        },
        "dimension_id": 23,
        "input_skill": "Prefect",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Data Engineer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 112,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Workflow Orchestration for ML Pipelines",
          "id": 54,
          "rationale": "Workflow engines used to coordinate training, evaluation, deployment, and retraining jobs. This cluster covers dependencies, retries, scheduling, and pipeline composition for ML lifecycle automation.",
          "slug": "workflow-orchestration-for-ml-pipelines",
          "source": "db"
        },
        "dimension_id": 54,
        "input_skill": "Prefect",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Ops Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 112,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Container Orchestration Platforms",
          "id": 134,
          "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
          "slug": "container-orchestration-platforms",
          "source": "db"
        },
        "dimension_id": 134,
        "input_skill": "Kubernetes",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 726,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Kubernetes for ML Workloads",
          "id": 47,
          "rationale": "Kubernetes-native components used to schedule, accelerate, and isolate ML training and serving workloads. This includes GPU enablement and ML-specific controllers rather than generic cluster administration.",
          "slug": "kubernetes-for-ml-workloads",
          "source": "db"
        },
        "dimension_id": 47,
        "input_skill": "Kubernetes",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "ML Ops Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 726,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Model Optimization and Acceleration",
          "id": 53,
          "rationale": "Techniques for improving inference latency, throughput, memory use, and training efficiency. ML engineers use these methods to meet production constraints without sacrificing too much quality.",
          "slug": "model-optimization-and-acceleration",
          "source": "db"
        },
        "dimension_id": 53,
        "input_skill": "Quantization",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 260,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 3,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Video Compression Algorithms",
          "id": 226,
          "rationale": "Core compression and decompression techniques that determine bitrate, quality, and decode cost. This cluster covers the algorithmic heart of codec engineering.",
          "slug": "video-compression-algorithms",
          "source": "db"
        },
        "dimension_id": 226,
        "input_skill": "Quantization",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Video Codec Engineer",
            "id": 22,
            "rationale": null,
            "role_archetype": null,
            "slug": "video-codec-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 260,
        "skill_tag": "in_db",
        "skipped_reason": null
      }
    ],
    "new_skills_created": 0,
    "role_dimension_saved": 0,
    "skill_dimension_saved": 0,
    "skipped": 1
  },
  "planner_output": null,
  "run_id": "0aa94386-7f59-430c-b6f7-8f25e5b5c76e"
}

LLM Calls

Every model call made for this run, in pipeline order. Click a card to see the model's response.

Loading…