Skip to main content
Pre-release

This release is a pre-release and may not be stable for production use.

Redis Feature Form Python SDK

redis-featureform is the Python SDK and ff CLI for Redis Feature Form.

Redis Feature Form gives data and ML teams a declarative workflow for defining providers, datasets, transformations, entities, features, labels, training sets, and feature views in Python while keeping existing offline data systems in place. Redis is the low-latency online store for feature serving.

Install from PyPI as redis-featureform, then import it in Python as featureform.

Official Redis Feature Form docs:

  • Overview: https://redis.io/docs/latest/develop/ai/featureform/overview/
  • Quickstart: https://redis.io/docs/latest/develop/ai/featureform/quickstart/
  • Documentation hub: https://redis.io/docs/latest/develop/ai/featureform/

Install

pip install redis-featureform

Optional extras:

pip install "redis-featureform[otel]"
pip install "redis-featureform[pyspark]"

What Redis Feature Form Does

Redis Feature Form helps you:

  • register offline systems and Redis as providers
  • define feature engineering resources as Python code
  • submit a complete resource graph into a workspace with ff apply or client.apply()
  • inspect the resulting plan before execution
  • query datasets and training sets over Arrow Flight
  • serve online feature values from Redis-backed feature views

Core Workflow

The Redis Feature Form workflow is:

  1. Create a workspace.
  2. Register providers for offline systems and the Redis online store.
  3. Author resources in Python.
  4. Apply or merge the resource graph into the workspace.
  5. Let Redis Feature Form plan and run the required execution work.
  6. Query offline results for training or fetch online features for inference.

Connection Defaults

The Python ff CLI and Client() default to the gRPC control-plane endpoint on localhost:9090. REST remains available only when explicitly selected with --transport rest, FEATUREFORM_TRANSPORT=rest, or transport="rest".

Bare loopback gRPC targets such as localhost:9090 default to plaintext for local development. Remote gRPC targets default to TLS unless plaintext is requested explicitly with --no-tls in the CLI or with an http://host:port gRPC target in the SDK.

Featureform also exposes a REST API on port 8080. If gRPC and REST run in the same FEATUREFORM_SERVER_MODE=all process, they share in-memory state. If they run as separate processes with STATE_BACKEND=memory, each process has its own state store; use STATE_BACKEND=postgres to share state across processes.

TLS / trust store

When no CA bundle is configured, the SDK and ff verify server certificates against the operating system trust store: the macOS keychains, the Windows certificate store, or the Linux distribution bundle. This applies to every TLS connection the client makes: REST, the OIDC identity provider, gRPC, and Arrow Flight. Private roots that MDM or group policy install into the OS store work with no Featureform-specific configuration.

  • FEATUREFORM_TRUST_STORE=system (the default) uses the OS trust store. HTTPS verifies through native OS APIs. gRPC and Flight use the OS trust anchors exported once per process. If that export fails, they fall back to grpcio's bundled roots. The export follows the OS's trust decisions:
    • macOS: the system roots, plus keychain certificates that admin or user trust settings mark as trusted for SSL. Roots that trust settings deny are removed. Certificates that were only imported into a keychain are not trusted.
    • Windows: the ROOT store merged with certifi's roots, because Windows downloads many public roots only on first use, minus anything in the Disallowed store.
    • Linux: the distribution CA bundle.
  • FEATUREFORM_TRUST_STORE=bundled restores the previous behavior: certifi for HTTPS (or, when a client certificate is configured, Python's default OpenSSL verify paths) and grpcio's bundled roots for gRPC and Flight. Any other value is rejected. The setting applies to ff, Client.from_env(), and Client.from_profile(). Directly constructed clients use Config(trust_store=...) and default to system. ff config resolve shows the effective mode.

A configured CA bundle (--ca-cert, FEATUREFORM_CA_CERT, or Client.from_profile(ca_cert_path=...)) replaces the default roots in every stack. The bundle therefore needs both the private root for the Featureform endpoint and any public roots the identity provider needs. --insecure takes precedence over both settings.

In system mode, the libraries' own root overrides still apply when set: SSL_CERT_FILE / SSL_CERT_DIR for HTTPS, and GRPC_DEFAULT_SSL_ROOTS_FILE_PATH for gRPC and Flight. Each one makes its stack use the library default, which reads the variable. A configured CA bundle takes precedence over them.

Known limitations:

  • The gRPC/Flight export does not check revocation. On macOS it also ignores trust settings limited to a single hostname or application. HTTPS connections don't have these gaps.
  • The OS export is computed once per process, so roots added while a process runs are not picked up until it restarts.

When ff auth login cannot reach auth discovery, the error names the failure class (TLS, unavailable, or deadline) and includes the underlying detail. For TLS failures, it also names the issuer of the server's certificate chain when the issuer can be determined.

Interactive authentication

Current servers advertise the login credential contract. ff auth login follows that default: paired OIDC authentication when enabled, or OAuth resource-server authentication when only resource tokens are supported. Use --credential-mode resource_token to explicitly select OAuth resource-server authentication when both are enabled, or --credential-mode id_token_pair to require paired OIDC authentication. Direct PKCE/device login with --issuer-url requires this option. Development password login supports only OAuth resource-server authentication.

Paired sessions store the ID token and access token together in protected session format version 2. Existing sessions require a fresh login. Keyring remains the default; file storage requires explicit FEATUREFORM_AUTH_STORAGE=file and uses private file permissions. Python clients reuse the whole pair for matching profile/deployment targets, including serving and Arrow Flight.

Refresh preserves the original granted scopes, including openid. An expired ID token, changed subject, or incompatible token pair requires re-login; the CLI never silently switches a paired session to resource-token authentication. Java and Featureform UI paired-session support are outside this RC.

Run make test-paired-auth from the repository root after installing Python and dashboard dependencies and the Playwright Chromium browser. This starts isolated OIDC/API/dashboard processes and verifies paired OIDC authentication and OAuth resource-server authentication, each enabled independently and together. Coverage includes login, refresh, expiry, re-login, authorization, and Python transport forwarding. Its dedicated bin/featureform-paired-auth-test binary has test-only licensing settings. The shared Python/Java session fixture is in contracts/examples/auth/.

Core Concepts

  • Workspace: logical boundary for a Redis Feature Form resource graph
  • Provider: connection to an external system such as Postgres, Snowflake, Spark, S3, Iceberg, or Redis
  • Resource: Python declaration of an entity, dataset, transformation, feature, label, training set, or feature view
  • Apply: single-shot workspace update that submits one combined resource set, computes a delta, and optionally runs an apply job
  • Merge: apply strategy that preserves omitted resources already present in the workspace
  • Execution mode: planning mode for runtime work, currently NORMAL, UPDATE, or FULL_REMATERIALIZE
  • Training set: offline, model-ready dataset composed from features and labels
  • Feature view: online-serving surface backed by Redis for inference-time lookup

Connect And Register Providers

The CLI is usually the fastest way to bootstrap Redis Feature Form resources:

ff --server grpc.example.com:443 --transport grpc auth login

ff --server grpc.example.com:443 --transport grpc \
  workspace create fraud-detection

ff --server grpc.example.com:443 --transport grpc \
  provider register analytics-postgres \
  --workspace fraud-detection \
  --type postgres \
  --pg-host postgres.example.com \
  --pg-port 5432 \
  --pg-database analytics \
  --pg-username ff_user \
  --pg-password-secret env:PG_PASSWORD

ff --server grpc.example.com:443 --transport grpc \
  provider register online-store \
  --workspace fraud-detection \
  --type redis \
  --redis-host redis.example.com \
  --redis-port 6379

For identity providers that require Authorization Code with PKCE instead of Device Authorization Flow, register a CLI redirect URI with the IdP and run:

ff --server grpc.example.com:443 --transport grpc auth login \
  --login-method authorization_code_pkce \
  --redirect-uri https://app.example.com/cli/callback

The CLI prints the authorization URL, then prompts for the full redirected URL or raw authorization code. The full redirected URL is preferred because it lets the CLI validate the login state locally; raw codes are accepted as a fallback and are verified by PKCE during token exchange. If your IdP requires a confidential CLI client, pass --login-client-secret or FEATUREFORM_LOGIN_CLIENT_SECRET; the secret is used only for that login and is not persisted.

Providers are registered separately from apply. Resource definitions then refer to those provider names when you define datasets, transformations, training sets, and Redis-backed feature views.

What ff apply Does

ff apply is the main authoring workflow in Redis Feature Form.

At a high level it:

  1. loads one Python entry file or package directory
  2. collects resources from either an explicit resources = [...] list or the global registry
  3. serializes the full resource graph into one request for one workspace
  4. compares the submitted graph with the current workspace graph
  5. returns a dry-run plan or commits the new version and optionally waits for the apply job

ff apply is graph-wide. It does not patch one object at a time.

Example Apply File

from datetime import timedelta

import featureform as ff
from featureform.types.resource import FeatureView, MaterializationEngine, TrainingSetType

postgres = ff.get_postgres("analytics-postgres")

customer = ff.Entity(
    name="customer",
    description="Customer entity for fraud models",
)

transactions = postgres.dataset(
    name="transactions",
    schema="public",
    table="transactions",
    timestamp_column="event_ts",
    description="Raw payment events",
)


@postgres.sql_transformation(
    name="customer_daily_rollups",
    description="Daily transaction totals per customer",
    inputs=[transactions],
)
def customer_daily_rollups() -> str:
    return """
        SELECT
            customer_id,
            date_trunc('day', event_ts) AS event_day,
            SUM(amount) AS total_amount,
            COUNT(*) AS transaction_count
        FROM {{transactions}}
        GROUP BY 1, 2
    """


customer_amount_7d = (
    ff.Feature(name="customer_amount_7d")
    .from_dataset(
        customer_daily_rollups,
        entity="customer",
        entity_column="customer_id",
        value="total_amount",
        timestamp="event_day",
    )
    .with_provider("analytics-postgres")
    .aggregate(function=ff.AggregateFunction.SUM, window=timedelta(days=7))
)

fraud_label = (
    ff.Label()
    .from_dataset(transactions)
    .value("is_fraud")
    .timestamp("event_ts")
    .entity("customer", column="customer_id")
    .build()
)

fraud_training = ff.TrainingSet(
    name="fraud_training",
    provider="analytics-postgres",
    features=[customer_amount_7d],
    label=fraud_label,
    type=TrainingSetType.STATIC,
)

customer_features = FeatureView(
    name="customer_features",
    entity="customer",
    features=[customer_amount_7d.name],
    inference_store="online-store",
    materialization_engine=MaterializationEngine.K8S,
)

resources = [
    customer,
    transactions,
    customer_daily_rollups,
    customer_amount_7d,
    fraud_label,
    fraud_training,
    customer_features,
]

Apply Strategies And Execution Modes

Redis Feature Form now exposes apply strategy and execution mode as separate axes.

Apply strategies:

  • APPLY strategy: submitted resources replace the desired graph for the workspace
  • MERGE strategy: submitted resources merge into the workspace and omitted resources are retained

Execution modes:

  • NORMAL: standard diff-based planning
  • UPDATE: revisit the target graph in update mode
  • FULL_REMATERIALIZE: revisit the target graph in full-rematerialize mode

That means combinations such as these are valid:

  • APPLY + NORMAL
  • APPLY + UPDATE
  • APPLY + FULL_REMATERIALIZE
  • MERGE + NORMAL
  • MERGE + UPDATE
  • MERGE + FULL_REMATERIALIZE

Apply From The CLI

Preview the graph delta without changing the workspace:

ff --server grpc.example.com:443 --transport grpc \
  apply -f resources.py --workspace fraud-detection --plan

Apply the submitted graph and wait for completion:

ff --server grpc.example.com:443 --transport grpc \
  apply -f resources.py \
  --workspace fraud-detection \
  --message "initial fraud pipeline" \
  --wait --wait-for finished

Merge into the existing workspace instead of replacing omitted resources:

ff --server grpc.example.com:443 --transport grpc \
  apply -f resources.py \
  --workspace fraud-detection \
  --merge \
  --wait --wait-for finished

Run a plan in update mode:

ff --server grpc.example.com:443 --transport grpc \
  apply -f resources.py \
  --workspace fraud-detection \
  --plan \
  --update

Request a merge with full rematerialization semantics:

ff --server grpc.example.com:443 --transport grpc \
  apply -f resources.py \
  --workspace fraud-detection \
  --merge \
  --full-rematerialize

Useful flags:

  • --plan: show what would change without applying
  • --merge: keep omitted resources already present in the workspace
  • --update: use update execution mode
  • --full-rematerialize: use full rematerialization execution mode
  • --wait --wait-for finished: block until the apply job completes and the workspace version is visible

Apply From Python

Use client.apply() for standard apply semantics:

import os

import featureform as ff
import resources

client = ff.Client(
    base_url="grpc.example.com:443",
    transport="grpc",
    token=os.environ["FEATUREFORM_TOKEN"],
)

result = client.apply(
    resources=resources.resources,
    workspace="fraud-detection",
    message="initial fraud pipeline",
    wait=True,
)

print(result.version)
for change in result.changes:
    print(change.resource_type, change.resource_name, change.action)

Use execution mode directly from Python:

plan = client.apply(
    resources=resources.resources,
    workspace="fraud-detection",
    dry_run=True,
    execution_mode="UPDATE",
)

Use merge semantics without deleting omitted resources:

result = client.merge(
    resources=resources.resources,
    workspace="fraud-detection",
    execution_mode="FULL_REMATERIALIZE",
    wait=True,
)

If resources is omitted, client.apply(...) and client.merge(...) use the global resource registry. That works well when definition modules register resources during import.

Query Offline Data

Use Arrow Flight helpers to pull datasets, training sets, or feature-view snapshots into pandas or stream them incrementally.

training = client.query_training_set(
    "fraud_training",
    workspace="fraud-detection",
    flight_server="grpc.example.com:9090",
).to_pandas()

print(training.head())

You can also query datasets directly:

transactions = client.query_dataset(
    "transactions",
    workspace="fraud-detection",
    limit=1000,
).to_pandas()

Serve Online Features From Redis

Once a feature view is materialized, Redis Feature Form serves online values from Redis with client.serve(...).

features = client.serve(
    "customer_features",
    entity="customer_123",
    workspace="fraud-detection",
)

print(features["customer_amount_7d"])

Batch serving is supported as well:

result = client.serve(
    "customer_features",
    entities=["customer_123", "customer_456"],
    workspace="fraud-detection",
    return_type="pandas",
)

Package Surface

  • featureform.Client: client for workspaces, providers, apply and merge, offline queries, and online serving
  • ff: CLI for auth, apply, workspace, provider, catalog, graph, scheduler, and RBAC operations
  • featureform.resources: typed resource DSL for authoring Redis Feature Form resource graphs
  • featureform.types: request and response models used by the client surface

Engineering Documentation

Use CLI Getting Started for ff endpoint, transport, authentication, and output behavior, and Applying Resource Definitions for plan/apply semantics. The repository engineering docs cover system architecture, resource/provider contracts, serving, examples, and server-state boundaries. This README remains the package entrypoint for installing and using the Python client.

Metadata

Release files for redis-featureform 3.3.0rc3

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for redis-featureform 3.3.0rc3
File Size Uploaded Provenance Actions
redis_featureform-3.3.0rc3.tar.gz 512.2 kB Without provenance Details for redis_featureform-3.3.0rc3.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for redis-featureform 3.3.0rc3
File Interpreter ABI Platform Actions
redis_featureform-3.3.0rc3-py3-none-any.whl Python 3 none any Details for redis_featureform-3.3.0rc3-py3-none-any.whl

Total release size: 1.1 MB

Release files / redis_featureform-3.3.0rc3.tar.gz

Download URL redis_featureform-3.3.0rc3.tar.gz
Size 512.2 kB
Tags Source
SHA-256 checksum
How to use checksums
9f5ef3fa27b660d581f3072220132879307dc61f28032be17996e3d56fd78e57
BLAKE2b-256 checksum
How to use checksums
0851deb3f2d7fa21f04a903630e31da4b63e4298e0afe9e7516e2b7d1f742937
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.14

Release files / redis_featureform-3.3.0rc3-py3-none-any.whl

Download URL redis_featureform-3.3.0rc3-py3-none-any.whl
Size 583.7 kB
Tags Python 3
SHA-256 checksum
How to use checksums
8ef2753c7d4fa4fd974b4b2eab4e120d8c79aaaf8570bc92daf75ada77d3cf96
BLAKE2b-256 checksum
How to use checksums
6dacf489d63d909b16464e6671e5202c5fe35b027d9e0a9b54bb012a19191488
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.14

Security for redis-featureform 3.3.0rc3

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page