Airflow + vector DB + FastAPI vs Pixeltable

Apache Airflow schedules DAGs. A multimodal app on Airflow still needs object storage, a vector database, and FastAPI. Pixeltable is that stack as one Python file: media in tables, transforms as computed columns, indexes and HTTP as declarations. Airflow remains the right tool for heterogeneous warehouse ETL.

pip install 'pixeltable[serve]'
See how it works

Scheduler vs the application schema

SidePixeltableAirflow
At a glance
  • Tables, computed columns, EmbeddingIndex, FastAPIRouter in one file
  • Insert a row; only that row’s dependents recompute
  • No separate vector DB or FastAPI project to keep aligned
  • Not a general-purpose DAG scheduler for warehouse ETL
  • Apache Airflow 3.3: TaskFlow DAGs via from airflow.sdk import dag, task
  • Schedules and retries tasks across systems you already run
  • A multimodal app still adds S3, a vector DB, and FastAPI
  • Best fit: heterogeneous batch, not an application catalog

A DAG of services vs one file

Airflow wins scheduling arbitrary tasks across systems you already run. Pixeltable wins insert-triggered multimodal pipelines and serving without that glue. Last reviewed: Oct 2026. Sources: airflow.apache.org 3.3 TaskFlow (airflow.sdk), docs.pixeltable.com.

FeaturePixeltableAirflow
What it is
Database + orchestration + serving in one Python file
DAG orchestrator; the stack around it is yours
Heterogeneous warehouse ETL
Not a replacement for company-wide DAG scheduling
The product: schedule, retry, and observe tasks across systems
Multimodal app glue
Schema is the pipeline; insert runs downstream work
You still wire object storage + vector DB + FastAPI
Incremental recompute
Changed rows only; cached columns otherwise
A DAG run; you encode incrementality in task code
Vector index
EmbeddingIndex on the source table
A task that upserts into Pinecone, Weaviate, or pgvector
HTTP serving
FastAPIRouter in the same file
A second service you deploy beside the DAG

Document RAG: one file vs the stack

Pixeltable: document_splitter, EmbeddingIndex, FastAPIRouter. Airflow 3.3 TaskFlow still leaves the vector DB and FastAPI as other boxes. Last reviewed: Oct 2026. Airflow: https://airflow.apache.org/docs/apache-airflow/stable/tutorial/taskflow.html

Pixeltable

import pixeltable as pxt
from pixeltable.functions.document import document_splitter
from pixeltable.functions.huggingface import sentence_transformer
from pixeltable.serving import FastAPIRouter
TableModel = pxt.model_base()
embed = sentence_transformer.using(
model_id='sentence-transformers/all-MiniLM-L6-v2'
)
class Docs(TableModel, name='docs'):
document: pxt.Document
title: pxt.String
class Chunks(
TableModel,
name='chunks',
base=Docs,
iterator=document_splitter(
document=Docs.document, separators='sentence,token_limit', limit=512
),
):
__indexes__ = [pxt.EmbeddingIndex(text, string_embed=embed)]
@pxt.query
def search_docs(query: str, limit: int = 5):
sim = Chunks.text.similarity(string=query)
return (
Chunks.order_by(sim, asc=False)
.limit(limit)
.select(Chunks.text, Chunks.title, sim)
)
api = FastAPIRouter(name='docs')
api.add_insert_route(Docs, path='/docs', inputs=[Docs.document, Docs.title])
api.add_query_route(path='/search', query=search_docs)

Airflow

from datetime import datetime
from airflow.sdk import dag, task
@dag(schedule=None, start_date=datetime(2026, 1, 1), catchup=False)
def rag_stack():
@task
def chunk_pdfs():
# Files still live in object storage you operate.
return [{'id': '1', 'text': 'Refund policy...'}]
@task
def embed(chunks):
return [{'id': c['id'], 'values': [0.1, 0.2]} for c in chunks]
@task
def upsert(vectors):
# index.upsert(vectors) # Pinecone, Weaviate, or pgvector
return len(vectors)
upsert(embed(chunk_pdfs()))
rag_stack()
# HTTP is a second FastAPI app that queries the vector DB and reads S3.

When each belongs

Use Pixeltable when

  • The app is media, models, and retrieval

    A coding agent writes one file. You review one diff. pip install pixeltable. Cloud is Limited Beta, not GA.

  • You were about to glue Airflow to a vector DB and FastAPI

    That stack is the comparison, not Airflow alone. Pixeltable replaces the glue for this job.

Use Airflow when

  • Heterogeneous warehouse DAGs

    Spark jobs, SaaS extracts, dbt, and SLAs across existing systems. Pixeltable is not that scheduler. Docs: https://airflow.apache.org/

  • The company already runs Airflow

    Keep it for those DAGs. Point a task at Pixeltable when the multimodal app should own the rows, or leave Pixeltable as the app and Airflow as the rest of the estate.

Making the right choice

  • Do not confuse the scheduler with the stack

    • Airflow is excellent at scheduling. The multimodal app still needs storage, an index, and HTTP.
    • Prefect and Temporal are the same aisle as Airflow. LangGraph is the agent-loop aisle (see Pixeltable vs LangChain).
    • Longer write-up (older snippets): https://www.pixeltable.com/blog/pixeltable-vs-airflow-ml-orchestration
    • Last reviewed: Oct 2026. Airflow 3.3 TaskFlow imports dag and task from airflow.sdk.

Frequently asked questions

One file for media, models, and HTTP. Keep Airflow for warehouse DAGs.

Declare tables, indexes, and routes in app.py. Apply with pxt schema update and pxt service update. Keep Airflow when the job is heterogeneous batch across existing systems.

pip install 'pixeltable[serve]'
See how it worksGet expert guidance