Fennel is the fastest way to ship realtime ML features

The complete platform for realtime feature engineering at any scale

Fennel removes the engineering friction from deploying realtime data pipelines, enabling ML teams to iterate on features at scale.

Python-Native Authoring

Define features using Python, Pandas and other familiar libraries instead of specialized DSLs.

Powerful Data Connectors

Prebuilt data connectors to ingest data from batch, streaming, and realtime sources like Postgres, S3, Snowflake, BigQuery, and more.

Fully Managed Infra Ops

Zero operational/management concerns with fully managed infrastructure deployed in our cloud or your VPC.

Native Testing & CI/CD

Out-of-the-box unit tests, integration tests, and CI/CD to rapidly iterate and deploy features to production with confidence.

Feature Versioning & Lineage

Versioned immutable features with full lineage tracking to maintain multiple versions of features, roll out bug fixes and track PII data.

Drift Monitoring & Data Quality

Typed schemas, data expectations, drift monitoring, and more to prevent, catch, and alert on data quality issues.

How does it work?

Vector Store

Upload/Generate embeddings

Some description of this section would go here.

# Specify inputs, entities and compute configuration
@batch_feature_view(
  description="Whether the user has a good credit score, updated daily",
  sources=[credit_scores],
  entities=[user],
  feature_start_time=datetime(2020, 10, 1),
  batch_schedule=timedelta(days=1),
)
# Define transformation logic
def user_credit_quality(credit_scores):
  return f'''
      SELECT
          USER_ID,
          IF (CREDIT_SCORE > 700, 1, 0) AS USER_HAS_GOOD_CREDIT,
          TIMESTAMP
      FROM
          {credit_scores}
      '''

Feature Store

Define realtime features

Some description of this section would go here.

# Specify inputs, entities, and compute configuration
@stream_feature_view(
  description="Mean transaction amount of last hour, 24h and 72h, updated every 10 min",
  source=transactions,
  entities=[user],
  feature_start_time=datetime(2020, 10, 1),
  # Define logic for time-window aggregations
  aggregation_interval=timedelta(minutes=10),
  aggregations=[
        Aggregation(column='AMOUNT', function='mean', time_window=timedelta(hours=1)),
        Aggregation(column='AMOUNT', function='mean', time_window=timedelta(hours=24)),
        Aggregation(column='AMOUNT', function='mean', time_window=timedelta(hours=72)),
  ],
)
# Define query to use in the transformation
def mean_transaction_amount(transactions):
  return f'''
      SELECT
          USER_ID,
          AMOUNT,
          TIMESTAMP
      FROM
          {transactions}
      '''

Model Store

Upload models

Some description of this section would go here.

# Indicate schema of incoming request-time data (e.g. live transaction data)
transaction_request = RequestSource([Field('amount', Float64)])

# Specify inputs and schema of the output
@on_demand_feature_view(
  description="Whether the current transaction amount is higher than the user's 
  weekly average.",
  sources=[transaction_request, historical_metrics],
  schema=[Field('transaction_amount_is_higher_than_average', Bool)],
)
# Define transformation logic
def transaction_amount_is_higher_than_average(transaction_request, historical_metrics):
  result = {}
  result['transaction_amount_is_higher_than_average'] = (
    transaction_request['amount'] >= historical_metrics['amount_7d_mean'])
  return result

Drift Monitoring

Some description of this section would go here.

Founded by a team of tech veterans who built ML infrastructure serving billions of people

Meet the team

Realtime Optimized

Compute & serve features in realtime

Second Level Feature Freshness

Fast Rust-based computation engine that updates features within seconds of new data being available.

Zero Online-Offline Skew

Consistent feature definitions, immutable and versioned features, and batch point-in-time correct training data eliminates the potential for skew.

Blazing Fast Online Serving

Custom-built KV store reduces RAM usage by keeping much of the data on SSD while still delivering single-digit millisecond lookups for realtime serving.

Affordable Realtime Performance

Rust engine optimized for low and predictable memory overhead compared to JVM systems, efficient compute, out-of-box support for spot instances, and a lot more to keep your costs down.