feast.dev

What is Feast?

Feast is an open-source feature store for machine learning: a system for defining, storing, discovering and serving the structured data that models use, both when training and when making live predictions. The core problem it addresses is consistency—making sure the same feature definitions feed offline training pipelines and online inference, so a model doesn't see different data in production than it learned from.

What it actually does

• Feature definitions as code. You declare features in a repository, and Feast manages how they are retrieved for each use.
• Historical retrieval. get_historical_features pulls point-in-time-correct training data for a set of entities, which is what prevents label leakage in time-sensitive problems.
• Online retrieval. get_online_features fetches the latest values for a single entity at low latency, the path used at inference time.
• Vector retrieval for RAG. retrieve_online_documents returns documents by similarity search, aimed at retrieval-augmented LLM applications.
• Pluggable stores. Feast connects to separate offline and online stores rather than owning the storage itself, so teams keep existing infrastructure.

Who it suits

The listed use cases—real-time recommendations, fraud detection, risk scoring, customer segmentation—share a pattern: features must be computed consistently across teams and reused across models. Feast fits organizations with several models or teams duplicating feature pipelines, or with a real-time serving requirement. A single analyst running one batch model offline gets little from it; the overhead of a feature repository pays off with reuse and online serving.

Trade-offs to weigh

Adopting Feast means running and operating it alongside your existing stores, and standardizing feature definitions across teams—an organizational change as much as a technical one. The separation of offline and online stores is flexible but requires you to keep both fed correctly. The RAG/vector capability is newer than the core feature-serving path, so evaluate it against your latency and scale needs rather than assuming parity.

Next step

Start from a single high-value model with an online requirement and define its features in a Feast repository, then compare online and offline values for the same entities to confirm consistency. For background, the project's documentation and community channels are the practical starting points; adjacent tools include Tecton for a managed commercial approach and MLflow if your immediate gap is experiment tracking rather than feature serving.

How does Feast keep features consistent between model training and real-time inference?

Feast keeps training and inference consistent by making both paths read from one shared feature definition rather than from two separately maintained pipelines. Teams register features in a feature repository, and the same named features (for example customer_stats:daily_transactions) are then requested through get_historical_features for training and get_online_features for inference. Because both calls reference the same definitions, the offline store and online store are populated from a common source of truth, which reduces the classic mismatch where a model is trained on one version of a feature and served another.

How the mechanism works in practice

• Single definition, two serving modes. Feature definitions live in code in the repository; the historical API reads from offline storage for point-in-time-correct training sets, while the online API reads low-latency values for inference.
• Point-in-time joins for training. get_historical_features takes an entity dataframe and returns feature values as they existed at each event timestamp, which prevents label leakage and mirrors what would have been available at prediction time.
• Entity-keyed online lookups. get_online_features takes entity rows (such as customer_id and product_id) and returns the latest values, so the same keys drive both the training join and the serving request.
• Shared features across teams. The site's customer segmentation use case describes consistent feature definitions across teams, which matters when several models consume the same signals.

Where consistency still depends on you

Feast provides the structure, but consistency is only as good as the materialization process that syncs offline data into the online store, and as good as the freshness of your ingestion. A reader building a fraud detection model, for instance, should verify that the behavioral features used at scoring time are materialized on a schedule that matches the transaction window, and should test that a sample entity returns the same values through both APIs before launch.

A practical next step

Pick one high-value feature, define it once in the repository, and run both APIs for the same entity set on the same day. Compare the values; any divergence points to a materialization or timestamp issue worth fixing before scaling to the full feature set. The page's own code sample is a reasonable template for that test, and the project's documentation at Feast covers repository setup and store configuration.

Can Feast support vector similarity search for retrieval-augmented generation (RAG) applications?

Yes. Feast includes a document-retrieval capability aimed at RAG: the retrieve_online_documents method shown on the page takes a list of document features (ID, chunk ID, chunk text, embedding) plus a natural-language query and returns matching chunks. That means the same feature store you use for training and online serving can also serve the retrieval step of a RAG pipeline.

What the page shows

• Retrieval call: store.retrieve_online_documents(features=[...], query="What is the biggest city in the USA?") — a query string is matched against stored embeddings rather than requiring you to pass a vector yourself.
• Document features: document_id, chunk_id, chunk_text, chunk_embedding — so chunking and embedding are modeled as features, not a separate side system.
• Vector search in the online store: a blog note describes vector search support arriving through a tighter online-store integration starting with Feast v0.65.

Practical implications

• Teams already on Feast can keep RAG retrieval next to their other features (user stats, product data) instead of standing up a separate vector database, which simplifies consistency between training-time and serving-time data.
• Chunk-level granularity means you control how documents are split and embedded; retrieval quality depends heavily on that chunking and on the embedding model you choose.
• Online-store dependency: vector search runs through the online store, so the choice of online store and its vector capabilities matters. Confirm your target store and Feast version support it before committing.

Next step

Check the Feast docs for retrieve_online_documents to see which online stores support vector search in your version, then prototype with a small corpus and compare retrieval quality against your current approach. Related reading: Feast and, if you are evaluating alternatives, Milvus or Weaviate for dedicated vector search.

Which online and offline stores can I connect to Feast?

Feast separates storage into two layers, and you connect each to the backend that fits its job: an offline store for historical feature generation during training, and an online store for low-latency feature retrieval during inference. The site's integrations section lists both as distinct categories, and its quick-start example shows the same feature definitions served both ways—get_historical_features for training data and get_online_features for inference—so the store choice affects performance and operations, not your feature definitions.

What the page shows

• Offline stores and online stores are presented as separate integration categories, which reflects the training/serving split above.
• IKV appears as a listed integration in the online-store area.
• ScyllaDB is described in a blog post as an online store with vector search support starting in Feast v0.65, covering configuration and why teams outgrow their existing online store.
• Aerospike is benchmarked on Feast's own benchmark harness in another post.
• Chronon is covered as a way to discover and retrieve Chronon features for training and inference, while Chronon itself owns computation and serving.

For the full, current list—including the common warehouses and key-value databases—check the Docs link on the site, since integrations change between releases.

How to choose

A concrete case: a recommendations team already running a key-value database for its API could point Feast's online store at it and keep its warehouse as the offline store, avoiding a second serving system. The trade-off is that you inherit that database's operational limits—the ScyllaDB post's framing of teams "outgrowing their existing online store" is the vendor's observation, and it is worth testing your own latency and scale before assuming a migration is needed.

Next step: list the databases your team already operates, map each to offline or online, and confirm support in the Docs before adding anything new.

How do I get started with Feast in my own feature repository?

Start by defining a small, real feature set in a repository, then point Feast at it and read features both historically (for training) and online (for inference). The page's own quickstart shows this pattern: initialize FeatureStore(repo_path="feature_repo"), call get_historical_features(...) with an entity DataFrame for training, and get_online_features(...) with entity rows for serving. If you are building retrieval for LLM or RAG use cases, the same store exposes retrieve_online_documents(...) for vector similarity search over document chunks.

A practical first-repository sequence

1. Pick one narrow use case. The page lists real-time recommendations, fraud detection, risk scoring and customer segmentation as intended scenarios. Choose one and define only the entities and features it needs (for example customer_id, product_id, plus a few transaction or value features).
2. Create a repository layout. Put feature definitions in Python modules under a feature_repo directory and keep entity keys, feature views and data sources together. This is the path the quickstart passes to FeatureStore.
3. Wire your existing stores. Feast sits in front of offline and online stores rather than replacing them; the page shows integrations for both categories. Use your warehouse or lake for historical data and a low-latency store for online reads.
4. Validate consistency before scaling. Fetch the same feature names through both historical and online APIs and confirm values agree for a few known entities. Consistency between training and inference is the core problem the product claims to solve, so test it early.
5. Add serving only after training reads work. Once historical retrieval returns sensible DataFrames, connect online reads to your application and measure latency for a single entity lookup.

Decisions that shape the setup

A concrete scenario: a small team building product recommendations can define a customer_stats view with daily transactions and lifetime value, generate a training DataFrame from last quarter's interactions, and serve the same two features for a live customer_id lookup. That single loop proves the repository works before anyone adds fraud or risk features.

For background on the project and its community, see Feast. If you later need a comparison point for a managed alternative, the official pages for Tecton describe a commercial feature platform, though its scope and licensing differ from an open-source repository you host yourself.

When would a team benefit from adopting a feature store instead of managing features ad hoc?

A team benefits from a feature store once the same features are needed by more than one model, more than one service, or by both offline training and online inference—and keeping those copies consistent becomes an engineering burden rather than a one-off scripting task. Feast, as an open source feature store, targets exactly that situation: its page describes delivering structured data to AI and LLM applications "at high scale during training and inference," with a single definition serving both paths.

Signals that ad hoc feature handling has become a cost

• Training/serving skew. Features are computed in a batch pipeline for training but recomputed differently in the application for inference, and predictions drift. Feast's example code shows one definition used through both get_historical_features and get_online_features.
• Duplicate work across teams. Several teams rebuild the same customer or product aggregates. The page's customer segmentation use case frames this as "consistent feature definitions across teams."
• Freshness requirements. Real-time recommendations and fraud detection need current interaction or behavioral features at request time, not yesterday's table.
• Discovery. New joiners cannot find which features exist or who owns them; a catalog with owners and metadata changes that.
• RAG and LLM workloads. The page shows retrieve_online_documents for vector similarity search, so teams mixing tabular features and document chunks in one serving layer have a concrete reason to look.

When it is probably not worth it

A single model, a small team, one batch pipeline, and no low-latency serving path are usually fine with a warehouse table and a script. A feature store adds a definition layer, a registry, and an online store to operate. The trade-off is real: you gain consistency, reuse, and a serving contract, and you take on infrastructure and a new abstraction your team must learn.

A practical decision test

Ask whether any feature is consumed by two or more of: a training job, a real-time API, another team's model. If yes, and the copies are maintained by hand, the store pays for itself. If no, revisit when the second consumer appears.

As a next step, list your current features, mark which are used in both training and serving, and count the teams involved. That inventory tells you whether the problem is consistency (Feast's core pitch) or purely latency, which points instead to the online-store integration question—the page notes its ScyllaDB and Aerospike work under integrations and blog posts. For background on the broader category, MLOps Community hosts practitioner discussion, and Feast itself carries the docs and quickstart referenced on the page.