Weaviate: Open-Source Vector Database with Hybrid Search

Defining a Weaviate Schema (Class + Properties)

In Weaviate, data is organized into classes (like database tables). Each class has typed properties and a vectorizer configuration.

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

client = weaviate.connect_to_weaviate_cloud(
    cluster_url="https://YOUR-CLUSTER.weaviate.network",
    auth_credentials=weaviate.auth.AuthApiKey("YOUR_API_KEY")
)

# Create a collection with OpenAI vectorizer
client.collections.create(
    name="Article",
    vectorizer_config=Configure.Vectorizer.text2vec_openai(
        model="text-embedding-3-small",
        dimensions=1536,
    ),
    generative_config=Configure.Generative.openai(model="gpt-4o-mini"),
    properties=[
        Property(name="title",   data_type=DataType.TEXT),
        Property(name="content", data_type=DataType.TEXT),
        Property(name="category",data_type=DataType.TEXT),
        Property(name="pubDate", data_type=DataType.DATE),
    ]
)

# Insert objects — Weaviate auto-generates the embedding
articles = client.collections.get("Article")
with articles.batch.dynamic() as batch:
    batch.add_object({
        "title":    "Introduction to RAG",
        "content":  "Retrieval-augmented generation combines search with LLMs...",
        "category": "ai",
        "pubDate":  "2024-01-15T00:00:00Z"
    })

client.close()

Hybrid Search: BM25 + Vector

Hybrid search combines dense vector similarity with sparse BM25 keyword matching. The alpha parameter controls the blend.

from weaviate.classes.query import Filter, MetadataQuery

articles = client.collections.get("Article")

# Hybrid search — alpha=0.7 weights vector search more than BM25
results = articles.query.hybrid(
    query="how does retrieval augmented generation work",
    alpha=0.7,              # 0 = pure BM25, 1 = pure vector
    limit=5,
    filters=Filter.by_property("category").equal("ai"),
    return_metadata=MetadataQuery(score=True)
)

for obj in results.objects:
    print(f"{obj.metadata.score:.4f} | {obj.properties['title']}")

# Pure vector search (nearText auto-vectorizes the query)
results_vec = articles.query.near_text(
    query="semantic search techniques",
    limit=3,
    filters=Filter.by_property("category").equal("ai")
)

# Generative search — retrieve + LLM in one call
results_gen = articles.generate.near_text(
    query="RAG architectures",
    single_prompt="Summarize this article in one sentence: {content}",
    limit=3
)
for obj in results_gen.objects:
    print(obj.generated)

Multi-Tenancy Configuration

Enable multi-tenancy at class creation. Each tenant gets an isolated shard that can be independently managed.

from weaviate.classes.config import Configure
from weaviate.classes.tenants import Tenant, TenantActivityStatus

# Create a multi-tenant collection
client.collections.create(
    name="CustomerDocs",
    multi_tenancy_config=Configure.multi_tenancy(enabled=True),
    vectorizer_config=Configure.Vectorizer.text2vec_openai()
)

col = client.collections.get("CustomerDocs")

# Add tenants
col.tenants.create([
    Tenant(name="tenant-acme"),
    Tenant(name="tenant-globex"),
])

# All CRUD operations are scoped to a tenant
tenant_col = col.with_tenant("tenant-acme")
tenant_col.data.insert({"content": "ACME private document"})

# Offload inactive tenant to cold storage (saves cost)
col.tenants.update([
    Tenant(name="tenant-acme", activity_status=TenantActivityStatus.INACTIVE)
])

# Delete a tenant and all its data
col.tenants.remove(["tenant-acme"])

Weaviate vs Pinecone vs Qdrant vs Chroma