Weaviate

Learning Objectives

• Understand what Weaviate is and how its object-oriented data model differs from other vector databases
• Identify Weaviate's distinctive features: schema-based collections, generative search, and multi-modal support
• Evaluate when Weaviate's structured data model and generative capabilities are the right fit

What Is Weaviate?

Weaviate is an open-source vector database that combines vector similarity search with a structured, schema-based data model — sitting between a traditional database and a pure vector store. Developed by Weaviate B.V. (Netherlands) and first released in 2019, it's one of the most mature open-source vector databases and is known for two distinctive capabilities: generative search (using an LLM to generate responses from retrieved results directly in the query) and multi-modal support (storing and searching text, images, and other data types in the same database).

Unlike Chroma (minimal API, no schema) or Qdrant (performance-first), Weaviate's philosophy is a richer data model: data is organized into typed collections with defined properties, enabling more structured queries and richer metadata management alongside vector search.

Core Features

Schema-Based Collections

Weaviate organizes data into typed collections with defined properties:

import weaviate
import weaviate.classes as wvc

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

# Define a typed collection with properties
client.collections.create(
    name="Article",
    vectorizer_config=wvc.config.Configure.Vectorizer.text2vec_openai(),
    properties=[
        wvc.config.Property(name="title", data_type=wvc.config.DataType.TEXT),
        wvc.config.Property(name="content", data_type=wvc.config.DataType.TEXT),
        wvc.config.Property(name="category", data_type=wvc.config.DataType.TEXT),
        wvc.config.Property(name="published", data_type=wvc.config.DataType.DATE),
    ]
)

Properties are typed (text, number, date, boolean, object, cross-reference) — providing more structure than the arbitrary key-value metadata in Pinecone or Qdrant.

Vectorizer Modules (Built-In Embedding)

Unlike Pinecone and Qdrant (which require pre-computed embeddings), Weaviate can generate embeddings automatically via vectorizer modules:

• text2vec-openai — OpenAI text embeddings
• text2vec-cohere — Cohere embeddings
• text2vec-huggingface — Any Hugging Face model
• multi2vec-clip — Multi-modal CLIP embeddings (text + images)
• text2vec-transformers — Self-hosted transformer models

# Add objects — Weaviate auto-embeds the text fields
collection.data.insert({
    "title": "Introduction to Vector Databases",
    "content": "Vector databases enable semantic similarity search...",
    "category": "ai",
    "published": "2026-01-15T00:00:00Z"
})
# No need to compute embeddings yourself — the vectorizer handles it

Generative Search

Weaviate's most distinctive feature: generative search passes retrieved objects directly to an LLM to generate a synthesized response — all within a single Weaviate query:

# Search and generate a response from the retrieved results
response = collection.generate.near_text(
    query="how do vector databases work?",
    limit=3,
    grouped_task="Summarize how vector databases work based on these results:"
)

print(response.generated)
# "Vector databases work by storing data as high-dimensional vectors and..."
# (LLM-generated from the 3 retrieved articles)

This eliminates a step in RAG pipelines — instead of retrieve → pass to LLM → get response, Weaviate does retrieve + generate in one call. The LLM response is generated server-side using the configured generative module (OpenAI, Cohere, Anthropic, or self-hosted).

Multi-Modal Support

Weaviate's multi2vec-clip module enables storing and searching across text and images in the same collection:

• Store products with both text descriptions and image embeddings
• Search with a text query and retrieve products where the image is the closest match
• Cross-modal search: "find images similar to this text description"

Hybrid Search

Weaviate supports BM25 keyword search alongside vector search, with a fusion algorithm to combine scores:

# Hybrid search: combine vector similarity + BM25 keyword matching
response = collection.query.hybrid(
    query="vector database performance benchmarks",
    alpha=0.5,  # 0 = pure keyword, 1 = pure vector, 0.5 = balanced
    limit=5
)

Deployment Options

Pricing (Weaviate Cloud)

Self-hosted is free (you pay your own server costs).

Strengths

• Generative search: Built-in LLM synthesis of retrieved results — simplifies RAG pipeline architecture
• Schema and typed properties: Richer data model than key-value metadata; better for structured domains
• Built-in vectorizers: No separate embedding pipeline required — Weaviate handles embedding on insert
• Multi-modal: Text + image search in the same collection via CLIP embeddings
• Hybrid search: BM25 + vector fusion with tunable alpha parameter
• Open source (BSD 3-clause): Self-host on any infrastructure; no vendor lock-in
• Mature ecosystem: One of the oldest vector databases; extensive documentation and community

Limitations & Considerations

• More complex setup: Schema definition, module configuration, and the richer data model require more initial setup than Chroma or Qdrant
• JVM overhead: Weaviate is written in Go, but some module components run in Python — memory overhead can be higher than Qdrant's Rust implementation
• Generative search limitations: Built-in generative search is less configurable than building a custom RAG chain — advanced prompt engineering requires the standard retrieve-then-generate approach
• Weaviate Cloud sandbox expiration: Free tier sandboxes expire after 14 days — production use requires a paid plan or self-hosting
• Smaller community than Pinecone: Fewer tutorials and community examples than the market leader

Best Use Cases

When to choose alternatives:

• Simplest possible setup → Chroma
• Best self-hosted performance → Qdrant
• Managed cloud, maximum scale → Pinecone
• Already using PostgreSQL/Supabase → Supabase Vector
• Already using MongoDB → MongoDB Atlas Vector Search

Getting Started

# Start Weaviate locally
docker run -p 8080:8080 -p 50051:50051 \
  -e QUERY_DEFAULTS_LIMIT=25 \
  -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true \
  -e DEFAULT_VECTORIZER_MODULE=none \
  semitechnologies/weaviate

pip install weaviate-client openai

import weaviate
import weaviate.classes as wvc
from openai import OpenAI

client = weaviate.connect_to_local()
openai_client = OpenAI()

# Create collection
client.collections.create(
    name="KnowledgeBase",
    properties=[
        wvc.config.Property(name="content", data_type=wvc.config.DataType.TEXT),
        wvc.config.Property(name="source", data_type=wvc.config.DataType.TEXT),
    ]
)
collection = client.collections.get("KnowledgeBase")

def embed(text):
    return openai_client.embeddings.create(
        input=text, model="text-embedding-3-small"
    ).data[0].embedding

# Insert with pre-computed embeddings
from weaviate.classes.data import DataObject
collection.data.insert(
    DataObject(
        properties={"content": "Weaviate supports multi-modal search", "source": "docs"},
        vector=embed("Weaviate supports multi-modal search")
    )
)

# Semantic search
results = collection.query.near_vector(
    near_vector=embed("how does multi-modal retrieval work?"),
    limit=3,
    return_properties=["content", "source"]
)
for obj in results.objects:
    print(obj.properties)

client.close()

Key Takeaways

• Weaviate is an open-source vector database with a schema-based data model, built-in vectorizer modules, generative search, and multi-modal support
• Generative search passes retrieved results directly to an LLM within the query, returning both the matched objects and an AI-synthesized response in one call
• Built-in vectorizer modules (OpenAI, Cohere, CLIP) embed data automatically on insert — no separate embedding pipeline required
• Multi-modal CLIP module enables searching text and images in the same collection with cross-modal queries
• Best for schema-driven knowledge bases, generative RAG applications, and multi-modal search; self-hosted or Weaviate Cloud deployment; Apache 2.0 licensed