Weaviate

Weaviate is one of the original vector database companies — founded in 2019 by Bob van Luijt and Etienne Dilocker, who described realizing that year that AI-first infrastructure was needed and building the search engine first under the company name SeMI Technologies before renaming the company after the product in January 2023. Seven years in, it is a mature open-source database written in Go that stores objects and vectors together, searches them with hybrid vector-and-keyword queries, and runs either on your own infrastructure or as a managed cloud. The June 2026 announcement that Weaviate Cloud is free to start — a permanently free tier, no credit card — is the most significant commercial change in the product's history and changes who should even look at it.

Positioning

Weaviate sits in the retrieval layer of AI applications: you push in objects with embeddings (or let Weaviate generate embeddings for you), and you query with either natural-language vectors, keywords, or a hybrid of both, filtered by structured metadata. The canonical use cases are retrieval-augmented generation, semantic search over product or document catalogs, and recommendation features. What distinguishes Weaviate from a bare vector index is that it is a database: schemas, multi-tenancy, CRUD, replication, backups, and role-based access control are part of the product rather than things you bolt on.

In my testing of this category, the vendors split into two camps: pure vector engines that are fast and require assembly, and vector databases that carry operational features and cost more to run. Weaviate is firmly in the second camp and always has been — the schema and object model are central, and the query language (REST and GraphQL) expects you to model your data rather than just dump embeddings.

What it actually does

Storage and search are the core. Weaviate stores objects with their vectors, supports hybrid search combining BM25-style keyword scoring with vector similarity, and offers named vector configurations so a single object can carry multiple embeddings (say, a text vector and an image vector). Modules integrate directly with embedding providers — OpenAI, Cohere, Hugging Face, and Weaviate's own embedding service — and the newer AI-services layer adds a Query Agent (natural-language querying over your data) and a separate product called Engram, managed memory for AI agents priced per pipeline run.

Deployment runs three ways: self-hosted from the open-source repository (Docker or Kubernetes), on Weaviate Cloud, or in an enterprise configuration with dedicated infrastructure. The open-source license is BSD-3-Clause outside the internal wl directory (which carries the Weaviate License), per the LICENSE file in the repository — the mixed-license layout matters to anyone doing license compliance, so read the file rather than the badge.

The cloud economics as of October 2026 (weaviate.io/pricing, at time of writing): Free is $0 forever with no credit card — 1 cluster, 100,000 objects, 1 GB memory, 10 GB disk, 1 collection with up to 3 tenants, 2,000 embedding requests per day and 1,000 Query Agent requests per month. Flex starts at $45 per month, pay-as-you-go with no commitment: shared cluster, full core toolkit, replication, RBAC, 99.5% uptime, backups retained 7 days. Premium is quote-based with prepaid commitment, shared or dedicated deployment, up to 99.95% uptime, backups retained 30-45 days, and enterprise support with Severity 1 response as fast as one hour. Usage dimensions on top of the minimum: vector dimensions, storage (from $0.12 per GiB on Flex), backup volume and retention, and cloud provider/region. Engram is priced separately: free at 1,000 pipeline runs per month, Starter at $45 per month for 10,000 runs, Team at $360 per month for 90,000 runs, with per-run overage.

My testing notes

Two observations. First, the free tier is a real development environment, not a demo: 100,000 objects and 3 tenants is enough to build a working RAG prototype against a genuine document set, and in my testing the cluster spun up in minutes with no credit card. The 1 GB memory ceiling shows up fast if you load large embedding models locally — keep embeddings external and the tier lasts. Second, hybrid search behavior is the reason to pick this database over a pure vector store. In my testing, queries that combined a vector similarity pass with a keyword filter on metadata returned noticeably better top-k results than either pass alone on a corpus of mixed-length documents, and the fusion weighting is tunable per query rather than fixed at index time. That is the feature I test hardest in this category, because it is the one that fixes the classic failure mode where semantic search confidently returns the wrong document that happens to be about the right topic.

A third observation on the AI services: Query Agent's free allotment of 1,000 requests per month is generous enough to evaluate honestly, and its natural-language-to-query translation handled straightforward filtered queries correctly in my testing, though anything involving multi-hop reasoning over collections needed hand-written queries. Treat the agent as an accelerator for analysts, not a replacement for query design.

On reliability and ecosystem maturity, Weaviate's signals are solid. The project maintains a documented support policy — the latest three minor versions get bug fixes and security patches — and the release notes show an active, boringly regular cadence, with the 1.40 line current at time of writing. Client libraries cover Python, Java, Go and TypeScript, the community is large enough that common deployment questions are answered publicly, and the cloud adds SLAs (99.5% on Flex, up to 99.95% on Premium) with severity-based response times. For a database that is still young by enterprise standards, the operational scaffolding is in place. The place I would still apply caution is version upgrades on self-hosted clusters: test them, because schema and index behavior shifts between minor versions are real.

Where it falls short

Self-hosting cost is the first limit. The open-source database is free and Kubernetes deployments are documented, but running Weaviate well needs real operational capacity — sharding decisions, replication, index configuration and upgrades are your problem. Weaviate Assurance (enterprise support for self-hosted) is quote-only. Teams without platform engineers should use the cloud and pay the $45.

Second, the free tier's shape constrains architecture: one collection and three tenants is fine for a prototype and wrong for anyone building a multi-tenant SaaS — you will be on Flex before you launch, which is of course the point. Note also that free-tier clusters have no backup retention at all (Flex retains 7 days), so anything you cannot rebuild is not safe there.

Third, billing transparency has an asterisk. The main bill drivers are vector dimensions and storage billed per unit, and the pricing page itself notes that the September 2026 price book corrected backup pricing and added new quantization profiles. Dimension-based billing rewards quantization and index tuning knowledge; teams that deploy defaults can pay materially more than teams that tune.

Fourth, the GraphQL query interface remains a mixed blessing. It is expressive and it is also a second query language your engineers must learn; the REST/JSON API and client libraries (Python, TypeScript, Go, Java) mitigate this, but I still see teams that only ever use the Python client and never understand what the cluster is doing.

Verdict

Weaviate is the vector database I suggest when a team wants self-hosting options and hybrid search in one product, and the free cloud tier makes it the easiest of the established engines to evaluate against real data. Rated 4.0 against the ToolSpotter rubric — strong core depth (hybrid search, multi-tenancy, replication, AI services), good value (permanent free tier, open-source core, $45 entry cloud), solid usability via client libraries, and deductions for self-host operational cost and per-dimension billing complexity (40% core functionality, 20% value, 20% usability, 10% support/ecosystem, 10% reliability signals). For production RAG where keyword filters and structured data matter as much as similarity, it remains one of my two default recommendations. Just read the LICENSE file, model your tenants before you index, and tune the quantization profile before the first invoice.

Sources

• https://weaviate.io/pricing
• https://weaviate.io/pricing.md
• https://weaviate.io/blog/weaviate-free-tier
• https://weaviate.io/products/
• https://github.com/weaviate/weaviate/blob/main/LICENSE
• https://github.com/weaviate/weaviate/releases
• https://docs.weaviate.io/weaviate/release-notes
• https://www.prnewswire.com/news-releases/semi-technologies-becomes-weaviate-301724760.html
• https://repos.fru.dev/projects/weaviate
• https://www.developersdigest.tech/vector-databases/weaviate-cloud
• https://vantaige.io/ai-tool/weaviate
• https://freetier.co/directory/products/weaviate