LogoLogo
master
master
  • Introduction
  • Blog
  • Community & getting help
  • Roadmap
  • Changelog
  • Getting started
    • Quickstart
    • GenAI
    • Architecture
      • Overview
      • Language
      • Push vs Pull Model
      • Write Patterns
      • Feature Transformation
      • Feature Serving and Model Inference
      • Role-Based Access Control (RBAC)
    • Concepts
      • Overview
      • Project
      • Data ingestion
      • Entity
      • Feature view
      • Feature retrieval
      • Point-in-time joins
      • [Alpha] Saved dataset
      • Permission
      • Tags
    • Use Cases
    • Components
      • Overview
      • Registry
      • Offline store
      • Online store
      • Feature server
      • Batch Materialization Engine
      • Provider
      • Authorization Manager
      • OpenTelemetry Integration
    • Third party integrations
    • FAQ
  • Tutorials
    • Sample use-case tutorials
      • Driver ranking
      • Fraud detection on GCP
      • Real-time credit scoring on AWS
      • Driver stats on Snowflake
    • Validating historical features with Great Expectations
    • Building streaming features
    • Retrieval Augmented Generation (RAG) with Feast
  • How-to Guides
    • Running Feast with Snowflake/GCP/AWS
      • Install Feast
      • Create a feature repository
      • Deploy a feature store
      • Build a training dataset
      • Load data into the online store
      • Read features from the online store
      • Scaling Feast
      • Structuring Feature Repos
    • Running Feast in production (e.g. on Kubernetes)
    • Customizing Feast
      • Adding a custom batch materialization engine
      • Adding a new offline store
      • Adding a new online store
      • Adding a custom provider
    • Adding or reusing tests
    • Starting Feast servers in TLS(SSL) Mode
  • Reference
    • Codebase Structure
    • Type System
    • Data sources
      • Overview
      • File
      • Snowflake
      • BigQuery
      • Redshift
      • Push
      • Kafka
      • Kinesis
      • Spark (contrib)
      • PostgreSQL (contrib)
      • Trino (contrib)
      • Azure Synapse + Azure SQL (contrib)
      • Couchbase (contrib)
    • Offline stores
      • Overview
      • Dask
      • Snowflake
      • BigQuery
      • Redshift
      • DuckDB
      • Couchbase Columnar (contrib)
      • Spark (contrib)
      • PostgreSQL (contrib)
      • Trino (contrib)
      • Azure Synapse + Azure SQL (contrib)
      • Clickhouse (contrib)
      • Remote Offline
    • Online stores
      • Overview
      • SQLite
      • Snowflake
      • Redis
      • Dragonfly
      • IKV
      • Datastore
      • DynamoDB
      • Bigtable
      • Remote
      • PostgreSQL
      • Cassandra + Astra DB
      • Couchbase
      • MySQL
      • Hazelcast
      • ScyllaDB
      • SingleStore
      • Milvus
    • Registries
      • Local
      • S3
      • GCS
      • SQL
      • Snowflake
      • Remote
    • Providers
      • Local
      • Google Cloud Platform
      • Amazon Web Services
      • Azure
    • Batch Materialization Engines
      • Snowflake
      • AWS Lambda (alpha)
      • Spark (contrib)
    • Feature repository
      • feature_store.yaml
      • .feastignore
    • Feature servers
      • Python feature server
      • [Alpha] Go feature server
      • Offline Feature Server
      • Registry server
    • [Beta] Web UI
    • [Beta] On demand feature view
    • [Alpha] Vector Database
    • [Alpha] Data quality monitoring
    • [Alpha] Streaming feature computation with Denormalized
    • Feast CLI reference
    • Python API reference
    • Usage
  • Project
    • Contribution process
    • Development guide
    • Backwards Compatibility Policy
      • Maintainer Docs
    • Versioning policy
    • Release process
    • Feast 0.9 vs Feast 0.10+
Powered by GitBook
On this page
  • Overview
  • Key Capabilities for GenAI
  • Vector Database Support
  • Retrieval Augmented Generation (RAG)
  • Transforming Unstructured Data to Structured Data
  • Feature Transformation for LLMs
  • Use Cases
  • Document Question-Answering
  • Knowledge Base Augmentation
  • Semantic Search
  • Scaling with Spark Integration
  • Learn More

Was this helpful?

Edit on GitHub
Export as PDF
  1. Getting started

GenAI

Overview

Feast provides robust support for Generative AI applications, enabling teams to build, deploy, and manage feature infrastructure for Large Language Models (LLMs) and other Generative AI (GenAI) applications. With Feast's vector database integrations and feature management capabilities, teams can implement production-ready Retrieval Augmented Generation (RAG) systems and other GenAI applications with the same reliability and operational excellence as traditional ML systems.

Key Capabilities for GenAI

Vector Database Support

Feast integrates with popular vector databases to store and retrieve embedding vectors efficiently:

  • Milvus: Full support for vector similarity search with the retrieve_online_documents_v2 method

  • SQLite: Local vector storage and retrieval for development and testing

  • Elasticsearch: Scalable vector search capabilities

  • Postgres with PGVector: SQL-based vector operations

  • Qdrant: Purpose-built vector database integration

These integrations allow you to:

  • Store embeddings as features

  • Perform vector similarity search to find relevant context

  • Retrieve both vector embeddings and traditional features in a single API call

Retrieval Augmented Generation (RAG)

Feast simplifies building RAG applications by providing:

  1. Embedding storage: Store and version embeddings alongside your other features

  2. Vector similarity search: Find the most relevant data/documents for a given query

  3. Feature retrieval: Combine embeddings with structured features for richer context

  4. Versioning and governance: Track changes to your document repository over time

The typical RAG workflow with Feast involves:

┌─────────────┐     ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  Document   │     │  Document   │     │    Feast    │     │     LLM     │
│  Processing │────▶│  Embedding  │────▶│   Feature   │────▶│   Context   │
│             │     │             │     │    Store    │     │  Generation  │
└─────────────┘     └─────────────┘     └─────────────┘     └─────────────┘

Transforming Unstructured Data to Structured Data

Feast provides powerful capabilities for transforming unstructured data (like PDFs, text documents, and images) into structured embeddings that can be used for RAG applications:

  • Document Processing Pipelines: Integrate with document processing tools like Docling to extract text from PDFs and other document formats

  • Chunking and Embedding Generation: Process documents into smaller chunks and generate embeddings using models like Sentence Transformers

  • On-Demand Transformations: Use @on_demand_feature_view decorator to transform raw documents into embeddings in real-time

  • Batch Processing with Spark: Scale document processing for large datasets using Spark integration

The transformation workflow typically involves:

  1. Raw Data Ingestion: Load documents or other data from various sources (file systems, databases, etc.)

  2. Text Extraction: Extract text content from unstructured documents

  3. Chunking: Split documents into smaller, semantically meaningful chunks

  4. Embedding Generation: Convert text chunks into vector embeddings

  5. Storage: Store embeddings and metadata in Feast's feature store

Feature Transformation for LLMs

Feast supports transformations that can be used to:

  • Process raw text into embeddings

  • Chunk documents for more effective retrieval

  • Normalize and preprocess features before serving to LLMs

  • Apply custom transformations to adapt features for specific LLM requirements

Use Cases

Document Question-Answering

Build document Q&A systems by:

  1. Storing document chunks and their embeddings in Feast

  2. Converting user questions to embeddings

  3. Retrieving relevant document chunks

  4. Providing these chunks as context to an LLM

Knowledge Base Augmentation

Enhance your LLM's knowledge by:

  1. Storing company-specific information as embeddings

  2. Retrieving relevant information based on user queries

  3. Injecting this information into the LLM's context

Semantic Search

Implement semantic search by:

  1. Storing document embeddings in Feast

  2. Converting search queries to embeddings

  3. Finding semantically similar documents using vector search

Scaling with Spark Integration

Feast integrates with Apache Spark to enable large-scale processing of unstructured data for GenAI applications:

  • Spark Data Source: Load data from Spark tables, files, or SQL queries for feature generation

  • Spark Offline Store: Process large document collections and generate embeddings at scale

  • Spark Batch Materialization: Efficiently materialize features from offline to online stores

  • Distributed Processing: Handle gigabytes of documents and millions of embeddings

This integration enables:

  • Processing large document collections in parallel

  • Generating embeddings for millions of text chunks

  • Efficiently materializing features to vector databases

  • Scaling RAG applications to enterprise-level document repositories

Learn More

For more detailed information and examples:

PreviousQuickstartNextArchitecture

Last updated 4 days ago

Was this helpful?

Vector Database Reference
RAG Tutorial with Docling
Milvus Quickstart Example
Spark Data Source
Spark Offline Store
Spark Batch Materialization