MLflow + Feature Store: Track Features and Models Together (2026)

MLflow and Feature Store integration is less about tracking features and more about connecting the dots between your data and your models in a traceable, reproducible way.

Let’s see this in action. Imagine you’ve trained a model that predicts customer churn. You used a specific version of a feature set from your Feature Store, say customer_features version v3. You also used a particular MLflow run to train that model, say run ID a1b2c3d4e5f6.

Here’s how you’d log that connection from your MLflow training script:

import mlflow
from feature_store_client import FeatureStoreClient

# Assume you have a FeatureStoreClient instance
fs_client = FeatureStoreClient()

# Get the specific feature set version you're using
feature_set_version = fs_client.get_feature_set_version("customer_features", "v3")

# Start an MLflow run
with mlflow.start_run() as run:
    run_id = run.info.run_id
    print(f"MLflow Run ID: {run_id}")

    # Log the feature store artifact and its version
    mlflow.log_artifact(
        feature_set_version.path, # This is the actual data path or reference
        artifact_path="feature_set"
    )
    mlflow.log_param("feature_set_name", "customer_features")
    mlflow.log_param("feature_set_version", "v3")

    # ... (your model training code here) ...

    # Assume you saved your model and got its artifact URI
    model_artifact_uri = "runs:/a1b2c3d4e5f6/model" # Example URI

    # Log the model, linking it back to the feature set
    mlflow.log_model(
        artifact_path="model",
        model_uri=model_artifact_uri, # This is your trained model
        registered_model_name="customer_churn_predictor",
        input_example=None, # Optional: log an example input
        signature=None, # Optional: log the model signature
        # Crucially, add metadata about the feature store
        metadata={
            "feature_store_name": "customer_features",
            "feature_store_version": "v3"
        }
    )

print("Model logged with feature store lineage.")

When you later retrieve this model from MLflow, you can inspect its metadata to see exactly which version of customer_features was used. If you’re using a Feature Store client that supports it, you might even be able to retrieve the exact data snapshot used for training.

The core problem this solves is the "where did this data come from?" question that plagues machine learning projects. Without this integration, you have a trained model artifact, but no clear, auditable link to the specific data version that produced it. This makes reproducing experiments, debugging model drift, and understanding feature impact incredibly difficult.

Internally, the integration relies on a few key mechanisms:

Feature Store Versioning: Your Feature Store must have a robust versioning system. Each time you update or create a feature set, it gets a unique, immutable identifier (like v3 or a timestamped commit hash).
MLflow Artifacts and Metadata: MLflow treats everything logged in a run as an artifact. You can log the reference to your feature set version as an artifact. More importantly, you can attach arbitrary key-value metadata to MLflow models. This is where you store the feature_store_name and feature_store_version.
Model Registry Integration: When you register a model in MLflow, the metadata associated with the model artifact is carried over. This means a registered model carries its lineage information.
Feature Store Client API: A Feature Store client library is essential. It provides the programmatic interface to query feature sets, retrieve their versions, and get the necessary references (like file paths or database query strings) to access the actual data.

The levers you control are primarily in your training script:

Feature Set Identification: How precisely you identify the feature set version (e.g., using named versions like v3 or specific commit hashes).
Metadata Logging: The keys and values you choose for the metadata dictionary when logging your model. Consistency here is key.
Artifact Logging: Whether you log a direct reference to the feature set data or just its identifier. Logging the identifier is often sufficient for lineage.

When you deploy a model that was logged this way, your deployment pipeline can query the Feature Store using the stored feature_store_name and feature_store_version to ensure it’s using the exact same feature logic for inference as was used during training. This is crucial for avoiding inference-time data skew.

The most surprising aspect of this integration is that it doesn’t necessarily require the Feature Store to physically move data into MLflow. Instead, MLflow stores the pointers and metadata that allow you to reconstruct the training environment. MLflow becomes the central registry for your experiments and models, and the Feature Store becomes the versioned source of truth for your features. The integration bridges these two by embedding Feature Store lineage into MLflow model metadata.

Once you’ve successfully linked your models to their feature versions, the next logical step is to automate the retraining pipeline based on feature drift detection.