Is Pixeltable a Weaviate alternative?

For typical document and multimodal RAG, yes: put EmbeddingIndex on the column and query with similarity(string=). For hybrid BM25 plus dense fusion, or a dedicated Weaviate cluster, no — keep Weaviate.

How is this different from Pixeltable vs Pinecone?

Pinecone is a managed vector index. Weaviate adds hybrid search, named vectors, and a self-hosted option. The Pixeltable side is the same: the index lives on the source row.

Do I need a vector database?

You need an embedding index. You need Weaviate (or Pinecone, Qdrant, Chroma, pgvector) when that engine is the serving contract. See /learn/vector-database-alternatives-for-multimodal-apps. Last reviewed: Oct 2026.

Pixeltable vs Weaviate

Weaviate is a vector database with collections, named vectors, and hybrid search that fuses BM25 with dense similarity. Pixeltable is not a vector database: it declares EmbeddingIndex on the table that holds the source file. Keep Weaviate when that engine is the serving contract.

pip install 'pixeltable[serve]'

See how it works

Hybrid index vs the source row

Side	Pixeltable	Weaviate
At a glance	Chunking, embeddings, and similarity live on the table Insert and delete keep the index current — no upsert job Source media stays queryable next to the vector HTTP from the same file if you declare FastAPIRouter	Open-source vector database; Weaviate Cloud is the hosted option Hybrid search: BM25 fused with dense similarity (alpha balances the two) Collections, named vectors, and vector_config=Configure.Vectors.* You still chunk files, store bytes, and put HTTP in front

Collection of vectors vs index on the media table

Weaviate wins hybrid BM25 plus dense fusion, named vectors, and a dedicated ANN service. Pixeltable wins insert-keeps-the-index-current and typed media beside the vector. Last reviewed: Oct 2026. Sources: docs.weaviate.io (hybrid search, vector_config), docs.pixeltable.com/datastore/embedding-index.

Feature	Pixeltable	Weaviate
What it is	Tables + computed columns + EmbeddingIndex	Vector database of objects and vectors (hybrid search)
Hybrid BM25 + dense	Dense similarity on a column; keyword filters are table queries	query.hybrid fuses BM25 and dense (alpha, fusion_type)
Keeping vectors in sync	Index is schema; insert/delete/update recompute the affected rows	Insert into the collection; you still embed or configure a vectorizer
Source media	Document, Image, Video, Audio columns next to the index	Properties plus vectors; bytes live in object storage you add
ANN / serving scale	EmbeddingIndex on the catalog; not a dedicated ANN cluster	The product: HNSW, replicas, Weaviate Cloud
Glue around it	One schema	Chunker + embedder (or vectorizer module) + the collection + HTTP

Document search

Pixeltable: document_splitter view and EmbeddingIndex. Query with similarity(string=). Weaviate Python v4: collections.create with vector_config, then query.hybrid. Last reviewed: Oct 2026.

Pixeltable

import pixeltable as pxt
from pixeltable.functions.document import document_splitter
from pixeltable.functions.huggingface import sentence_transformer

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)]

if __name__ == '__main__':
    # After: pxt schema update app.py search
    docs = pxt.get_table('search.docs')
    docs.insert([{'document': 'handbook.pdf', 'title': 'Handbook'}])
    chunks = pxt.get_table('search.chunks')
    sim = chunks.text.similarity(string='refund policy')
    chunks.order_by(sim, asc=False).limit(5).select(chunks.text, chunks.title)

Weaviate

import weaviate
from weaviate.classes.config import Configure, DataType, Property

client = weaviate.connect_to_local()
docs = client.collections.create(
    'Document',
    vector_config=Configure.Vectors.text2vec_openai(),
    properties=[
        Property(name='title', data_type=DataType.TEXT),
        Property(name='body', data_type=DataType.TEXT),
    ],
)
docs.data.insert({'title': 'Handbook', 'body': 'Refund policy...'})
hits = docs.query.hybrid(query='refund policy', alpha=0.5, limit=5)
# Chunking PDFs and storing the original file are still outside this collection.

When each belongs

Choose Pixeltable when

RAG where the source row matters
Documents, images, or video plus the embedding. Insert should update the index. You do not want a second upsert path.
You were about to buy a vector database for an app
App-scale retrieval does not require Weaviate. Coming from a vector DB: docs.pixeltable.com/howto/coming-from

Choose Weaviate when

Hybrid search is the product
BM25 fused with dense vectors, named vectors, or a Weaviate Cloud SLA other services already call. Pixeltable can still produce embeddings.
The collection is already the serving contract
Keep Weaviate. Do not rewrite it into Pixeltable just to “have one vendor.” Roundup: /learn/vector-database-alternatives-for-multimodal-apps

Making the right choice

Same aisle as Pinecone, different surface
- Pinecone is managed ANN. Weaviate is hybrid search plus an open-source engine. That is why this page exists separately.
- Qdrant, Chroma, and Milvus remain the same job as Pixeltable vs Pinecone; they do not each get a vs page.
- Last reviewed: Oct 2026. Weaviate docs: https://docs.weaviate.io/weaviate/search/hybrid and https://docs.weaviate.io/weaviate/manage-collections/vector-config

Frequently asked questions

Index on the row, or keep Weaviate for hybrid serving.

Declare tables and EmbeddingIndex in app.py. Apply with pxt schema update. Hand vectors to Weaviate when hybrid search at that engine is the product.