What Is Weaviate? Features, Pricing and Use Cases

Weaviate is an open source vector database, written in Go, that stores your data objects together with their embeddings and finds them by meaning, by keywords (BM25) or by both at once through hybrid search. It can create the embeddings for you through vectorizer modules, keep each user's data in a separate tenant, and expose its search to AI agents through a built in MCP server. You can self host it for free with Docker or Kubernetes, or use Weaviate Cloud, which has a free tier of 100,000 objects and paid plans that start at $45 a month. To see how it sits next to Qdrant, LanceDB and the rest, browse our vector databases directory.

This explainer covers what Weaviate is, how it works, what it costs and how to use it as memory for an AI agent. Facts were rechecked against the official Weaviate documentation, the pricing page and GitHub releases on October 28, 2026. The latest server release is v1.40.3 (October 28, 2026), and the Python client is weaviate-client 4.24.1 (October 26), which needs Python 3.10 or newer. We ran the memory example below against Weaviate 1.40.1 on October 21; 1.40.2 and 1.40.3 are patch releases on the same minor version with no breaking changes listed.

What Weaviate is used for

Weaviate is used wherever an application needs to find text, images or records by similarity instead of exact matches:

• Retrieval augmented generation (RAG): fetch the most relevant chunks of your documents and pass them to a model. Our guide to building a RAG pipeline with LangGraph shows that loop end to end.
• Semantic and hybrid search: a search box that understands "cheap flights in spring" and still matches an exact product code.
• Recommendations: "more like this" lookups on products, articles or tickets.
• Agent memory: facts, preferences and past decisions that an agent saves and recalls across sessions, scoped to one user.

The vocabulary is short. A collection is a set of objects with a shared schema. An object is one record: its properties (JSON style fields) plus one or more named vectors. A tenant is an isolated partition of a collection. A vectorizer module is an integration that turns text into vectors inside Weaviate, so your app can send plain text.

How Weaviate works

Each object's vectors go into a vector index. The default is HNSW, a graph index kept in memory for fast searches, and Weaviate Cloud also offers a cost optimized HFresh index plus vector compression to cut memory use. Properties go into inverted indexes, which power BM25 keyword search and filters.

How hybrid search works

Hybrid search runs the keyword search and the vector search together and fuses the two result lists into one. A single alpha value sets the balance: 0 is pure keyword search, 1 is pure vector search, and values in between mix them. Per the hybrid search docs, the default fusion method since v1.24 is relative score fusion, which combines the normalized scores rather than just the rank positions; ranked fusion is still available. If you run hybrid queries with paging, take the 1.40.3 patch: its release notes include fixes so both hybrid legs fetch up to the end of the requested page, and so rerank and generate run once for a nearText sub search. For agents this matters more than it sounds. Agents look up file names, error codes and ticket IDs, which pure semantic search can rank below a vaguely related sentence.

Vectorizers are optional. You can attach a module such as Weaviate Embeddings (hosted on Weaviate Cloud) or a third party embedding provider, and Weaviate embeds objects on insert and queries at search time. Or you bring your own vectors, which is what the example below does.

Run Weaviate locally

The quickest start is the official image:

docker run -p 8080:8080 -p 50051:50051 cr.weaviate.io/semitechnologies/weaviate:1.40.3

Port 8080 serves the REST API and 50051 serves gRPC, which the Python client uses for queries. The Docker docs note that this default turns on anonymous access and sends usage telemetry. On a laptop, publish the ports on 127.0.0.1 only. On any shared machine, switch on API key authentication in a docker-compose.yml before you load real data.

For tests and notebooks, the Python client also has Embedded Weaviate: weaviate.connect_to_embedded() downloads the server binary and starts it from your code. The docs mark it experimental and support it on Linux and macOS only. That is the mode we used for the example.

Weaviate as agent memory: a tested example

This sets up a memory collection with one tenant per user, stores a few notes and recalls one user's preference with a hybrid query:

import weaviate
from weaviate.classes.config import Configure, Property, DataType
from weaviate.classes.query import Filter, MetadataQuery

client = weaviate.connect_to_local()  # or connect_to_embedded() for tests

memory = client.collections.create(
    "Memory",
    properties=[Property(name="text", data_type=DataType.TEXT),
                Property(name="kind", data_type=DataType.TEXT)],
    vector_config=Configure.Vectors.self_provided(),
    multi_tenancy_config=Configure.multi_tenancy(
        enabled=True, auto_tenant_creation=True),
)

alice = memory.with_tenant("alice")
alice.data.insert({"text": "Prefers answers in Python", "kind": "preference"},
                  vector=embed("Prefers answers in Python"))
alice.data.insert({"text": "Deploys on Fly.io", "kind": "fact"},
                  vector=embed("Deploys on Fly.io"))
memory.with_tenant("bob").data.insert(
    {"text": "Prefers TypeScript", "kind": "preference"},
    vector=embed("Prefers TypeScript"))

question = "which language does the user prefer"
hits = alice.query.hybrid(
    query=question, vector=embed(question), alpha=0.75, limit=3,
    filters=Filter.by_property("kind").equal("preference"),
    return_metadata=MetadataQuery(score=True),
)
for obj in hits.objects:
    print(obj.properties["text"], obj.metadata.score)
client.close()

embed() stands for whatever embedding model you use. In our run, with small test vectors, the query returned only "Prefers answers in Python". Bob's note never appeared, even though it matched the question just as well, because it lives in a different tenant.

That isolation is the reason to use tenants for agent memory. The multitenancy docs say each tenant is stored on its own shard, and data in one tenant is not visible to another. Tenants can also be set to INACTIVE (kept on disk) or OFFLOADED (moved to cloud storage), so thousands of idle users do not hold memory. One rule to keep: pick the tenant in your code from the logged in session, never from text the model wrote.

Connect Weaviate to an agent

The built in MCP server

Weaviate ships a Model Context Protocol server inside the database, introduced as a preview in the 1.37 release. It serves Streamable HTTP at /v1/mcp on the REST port and exposes four tools: weaviate-collections-get-config, weaviate-tenants-list, weaviate-query-hybrid and weaviate-objects-upsert. On a self hosted instance it is off by default; set MCP_SERVER_ENABLED=true, and add MCP_SERVER_WRITE_ACCESS_ENABLED=true only if the agent should write. The MCP server docs show the Claude Code command:

claude mcp add-json weaviate-local '{"type":"http","url":"http://localhost:8080/v1/mcp","headers":{"Authorization":"Bearer YOUR_API_KEY"}}'

Two cautions from those docs. On Weaviate Cloud the server is always on and write access is allowed by default, so turn on "Enable MCP Read Only" or give the agent a key with the read only viewer role if it should only search. And with auto schema on (the default), an upsert with a mistyped collection name creates a new collection instead of failing. For background on when MCP is the right wrapper, see MCP server vs API.

Engram, the managed memory service

If you would rather not design the memory schema yourself, Weaviate's Engram (generally available since June 2026) is a managed service built on Weaviate. You send raw text or conversations, and it extracts facts, deduplicates them against what it already knows and serves them back through vector, BM25 or hybrid search, scoped by project and user. It has a Python SDK (weaviate-engram) and a REST API. Our AI agent memory comparison covers the same idea in Mem0, Letta and Zep.

Framework integrations

LangChain has a langchain-weaviate package and LlamaIndex has a Weaviate vector store, so you can drop Weaviate into an existing retriever without writing client code.

Weaviate Cloud pricing

• Self hosted: free. Code outside the repository's wl folder is BSD 3 Clause licensed. Some newer features, such as Namespaces in 1.40, need an enterprise license key.
• Free tier on Weaviate Cloud: one cluster per user, 100,000 objects, 1 GB of memory, 10 GB of disk, one collection with up to three tenants, plus 2,000 embedding requests a day and 1,000 Query Agent requests a month. It runs on AWS in two regions, with best effort availability and no backups.
• Flex: pay as you go from $45 a month, billed mainly on stored vector dimensions and storage, with 99.5% availability.
• Premium: prepaid contracts from $400 a month, shared (99.9% availability) or dedicated (99.95%), with SSO.

Weaviate updated its cloud price book on September 1, 2026, adding a price for RQ-4 compression and changing backup rates by region, so check the calculator on the pricing page for your own numbers.

Weaviate vs Pinecone, Qdrant and pgvector

Prices are from each vendor's pricing page (Pinecone, Qdrant) on October 24, 2026. Pinecone also has a Standard plan with a $50 monthly minimum and Enterprise from $500.

All four are solid choices for agent memory, and we make no speed claims between them. Pick Weaviate if you want embeddings and an MCP endpoint handled by the database itself. Pick Pinecone if you never want to run a database server and are fine with a closed managed service. Pick Qdrant if you prefer computing vectors in your app and filtering on payload fields; our Qdrant guide walks through the same memory pattern. For a store that runs inside your process with no server, read LanceDB vs Qdrant, and if you already run Postgres, pgvector may be all you need. For very large, mostly idle datasets, turbopuffer is a hosted option that keeps vectors on object storage, with no self hosted edition. For an embedded option against a database that scales to a cluster, see LanceDB vs Milvus. For the wider field, including Milvus, pgvector, Chroma and LanceDB, see the best open source vector database roundup.

FAQ

Is Weaviate free?

Yes, if you host it yourself: the core is open source under BSD 3 Clause. Weaviate Cloud also has a free tier (100,000 objects, one collection). Paid cloud plans start at $45 a month on Flex.

Is Weaviate open source?

Mostly. Source code outside the wl directory of the GitHub repository is BSD 3 Clause. Code inside it is under a separate enterprise license and is switched on with a license key.

What language is Weaviate written in?

Go. GitHub's language breakdown for the weaviate/weaviate repository is almost entirely Go, with official clients for Python, TypeScript, Go, Java and C#.

Does Weaviate have an MCP server?

Yes, built into the database. On a self hosted instance set MCP_SERVER_ENABLED=true and connect to /v1/mcp on the REST port; on Weaviate Cloud it is always on, with write access allowed until you switch on "Enable MCP Read Only".

Weaviate or Pinecone for a small project?

Weaviate if you want to run it locally first or keep the option to self host: the same code works against Docker, Embedded Weaviate and the free cloud tier. Pinecone if you want a managed service only and a flat $20 a month Builder plan when you outgrow its free Starter plan.

Is Weaviate better than Qdrant?

Neither wins everywhere. Weaviate does more inside the database (vectorizers, an MCP server, a Query Agent), while Qdrant keeps the server lean and leaves embedding to your app. Test both with your own data and filters.