MLRun

MLRun abstracts Kubernetes complexity by wrapping serverless function execution through Nuclio, enabling developers to define ML workloads (training, preprocessing, inference) as containerized functions that auto-scale on Kubernetes clusters. Functions are defined declaratively via MLRun's SDK/CLI, compiled to Nuclio specs, and executed with automatic resource allocation, GPU provisioning, and dependency management without manual container orchestration.

MLRun provides a declarative pipeline framework that chains data ingestion, preprocessing, training, and serving stages with automatic dependency resolution and execution scheduling. Each pipeline step is tracked with input/output artifacts, parameters, and metrics; the system auto-generates lineage graphs showing data flow and model provenance across experiments, enabling reproducibility and audit trails without manual logging.

MLRun provides a centralized experiment tracking system where data scientists and ML engineers can log experiments, compare results, and share findings across teams. Experiments are stored in a shared metadata repository with versioning, allowing team members to view all experiments, filter by parameters/metrics, and reproduce results from any experiment; the system supports experiment annotations, comments, and approval workflows for model promotion without requiring external collaboration tools.

MLRun supports both batch (scheduled, time-based) and real-time (event-driven, streaming) data pipelines through a unified execution model. Pipelines are defined once and can be triggered by schedules (cron), events (data arrival, model updates), or manual invocation; the system manages scheduling, resource allocation, and execution monitoring for both batch and streaming workloads without requiring separate orchestration tools.

MLRun maintains a versioned artifact registry for models, datasets, and pipeline outputs with automatic dependency tracking. Each artifact is versioned, tagged, and linked to the pipeline/experiment that produced it; the system tracks which artifacts depend on which data versions and code versions, enabling reproducibility and rollback. Users can query the registry by artifact type, version, or metadata, and retrieve specific versions for retraining or serving without manual file management.

MLRun includes a native feature store that manages feature definitions, transformations, and storage across batch and real-time contexts. Features are defined declaratively, computed from raw data via transformations, and cached in configurable backends (in-memory, Redis, database); the system serves features to training pipelines and inference endpoints with automatic versioning and point-in-time correctness for training/serving consistency.

MLRun provides a serving framework that deploys trained models as HTTP/gRPC endpoints on Kubernetes with automatic scaling based on request volume. Models are wrapped in serving classes that handle preprocessing, inference, and postprocessing; the system supports canary deployments (gradual traffic shifting) and A/B testing without manual load balancer configuration, with built-in monitoring of latency, throughput, and model performance metrics.

MLRun abstracts training execution across multiple ML frameworks (TensorFlow, PyTorch, scikit-learn, XGBoost, etc.) by wrapping training code in a standardized function interface. The system automatically provisions GPUs from the Kubernetes cluster, distributes training across multiple nodes using framework-native distributed training (Horovod, PyTorch DDP), and manages resource allocation without requiring users to write distributed training code or GPU management logic.

MLRun provides native integration with Hugging Face model hub, enabling direct loading of pre-trained LLMs and fine-tuning them within MLRun pipelines. Models are downloaded from Hugging Face, fine-tuned using MLRun's distributed training infrastructure with GPU support, and deployed as serving endpoints; the system handles model versioning, caching, and compatibility with Hugging Face tokenizers and inference libraries without custom integration code.

MLRun integrates NVIDIA NIM (NVIDIA Inference Microservices) to optimize model inference performance through quantization, batching, and GPU-accelerated kernels. Models deployed via MLRun can be automatically optimized with NIM, reducing latency and increasing throughput for inference endpoints without requiring manual optimization code; the system handles NIM container orchestration on Kubernetes and metric collection for performance monitoring.

MLRun includes data validation capabilities that check data quality, schema compliance, and statistical properties at each pipeline stage. Validation rules are defined declaratively (schema, value ranges, null checks, statistical thresholds), executed automatically during pipeline runs, and trigger alerts or pipeline halts if data quality degrades; the system tracks data quality metrics over time to detect drift or anomalies without manual data inspection.

MLRun provides production model monitoring that tracks inference performance metrics (latency, error rate, prediction distribution) and data quality in real-time. The system automatically detects performance degradation or data drift and triggers retraining pipelines without manual intervention; monitoring rules are defined declaratively (e.g., 'retrain if accuracy drops below 90%'), and retraining jobs are scheduled and executed using the same pipeline infrastructure.

MLRun abstracts underlying infrastructure (on-premises Kubernetes, AWS EKS, Google GKE, Azure AKS) through a unified API, enabling ML pipelines to run on any Kubernetes cluster without code changes. The system handles cloud-specific integrations (S3, GCS, Azure Blob Storage), manages credentials and authentication, and provides consistent resource allocation semantics across clouds; users define pipelines once and deploy to multiple clouds or hybrid environments by changing configuration.