🛠️ AI Tool Lab Daily updates · 500+ AI tools

What You Need to Know About Weaviate (From Someone Who Runs It)

I have been running Weaviate in production since mid-2024. I started with Pinecone, got annoyed by the pricing, tried Qdrant (Rust, fast, limited ecosystem), and landed on Weaviate for the GraphQL API and the built-in vectorizer modules. I now run it for three clients — a legal document search system, an e-commerce product recommendation engine, and an internal knowledge base for a 40-person consulting firm.

The simplest way to explain Weaviate: it is a database that stores not just text and numbers, but the *meaning* of your data. You feed it documents, images, or audio, it turns them into mathematical vectors (embeddings), and when you search, it finds items by semantic similarity, not just keyword matching.

What makes Weaviate different from the other vector databases I have used: it speaks GraphQL natively (no bolt-on, no adapter layer), it can generate embeddings for you (no separate embedding service), and its hybrid search — combining old-school BM25 keyword matching with vector similarity — is the best I have seen. If someone searches your legal database for "breach of fiduciary duty" and your document says "violation of trustee obligation," Weaviate finds it. Elasticsearch would not.

---

The Features That Actually Matter in Production

GraphQL API — Not a Marketing Gimmick

Most vector databases give you a REST API or a Python client. Weaviate gives you GraphQL. This sounds like a minor implementation detail. It is not.

The reason it matters: in a RAG system, you almost never do a single vector search and call it done. You filter by date, by category, by user ID, by document status. You combine vector search with keyword search. You paginate, sort, aggregate. With REST APIs, this means chaining 3-4 calls and merging results in application code — slow, error-prone, and hard to debug.

With GraphQL, it is one query. Here is a real query from my legal search system:

{
  Get {
    LegalDocument(
      nearText: {concepts: ["non-compete agreement California 2024"]}
      where: {
        operator: And
        operands: [
          {path: ["jurisdiction"], operator: Equal, valueString: "California"}
          {path: ["date"], operator: GreaterThan, valueDate: "2023-01-01"}
        ]
      }
      limit: 10
    ) {
      title
      jurisdiction
      date
      _additional { distance }
    }
  }
}

One request. Hybrid search (keyword + vector), metadata filtering, and result ranking — all on the database side. This query runs in 22ms on a 5M-vector collection. Doing the same thing with separate REST calls and application-level merging took 180-240ms.

Built-in Vectorizers — Skip the Embedding Pipeline

This is the feature that saves me the most time. Most vector database workflows look like this: ingest text → send to OpenAI API → receive embeddings → store embeddings in DB → index → query. That is 3-4 microservices before you even have search working.

With Weaviate's module system, you configure a vectorizer once in the schema:

{
  "class": "Document",
  "vectorizer": "text2vec-openai",
  "moduleConfig": {
    "text2vec-openai": {
      "model": "text-embedding-3-small",
      "dimensions": 1536
    }
  }
}

After that, you send raw text directly and Weaviate calls OpenAI for you, stores the embedding, indexes it, and makes it searchable — all in one request. For prototyping, this cuts 2-3 days of infrastructure work. For production, I still prefer generating embeddings in a separate pipeline (more control, better batching, no API dependency in the hot path), but for MVPs and internal tools, the built-in modules are a real accelerant.

Hybrid Search — When Keywords and Semantics Work Together

This is the feature that made me switch from Qdrant. Pure vector search is great for "find things like this." But real-world search is messier. Users type partial keywords, product codes, dates, and proper names that vector search handles poorly.

Weaviate's hybrid search runs BM25 (the same algorithm Elasticsearch uses) and vector similarity in the same query, then merges results with a configurable fusion algorithm. You can set alpha=0.75 to weight vector search higher, or alpha=0.25 to prioritize exact keyword matches.

Real example from my e-commerce client: a search for "Sony WH-1000XM5 noise canceling headphones black" would confuse pure vector search (too many words, the model gets lost). Pure keyword search would miss the intent ("noise canceling" vs products described as "ANC"). Hybrid search gets the exact product in position 1, every time.

---

How to Make Money With Weaviate

Here is where Weaviate gets interesting from a business perspective. The tool itself is free (BSD-3 license). The money is in what you build with it.

Path 1: RAG Consulting for SMBs

The model: you build custom knowledge base search systems for businesses drowning in documents. Law firms with decades of case files. Medical clinics with patient records across 4 different EMR systems. SaaS companies with 500 support articles nobody reads.

What you charge: $3,000-$8,000 setup (1-2 weeks of work) + $300-$800/month hosting and maintenance retainer.

What it costs you: $40-$80/month for a Hetzner or DigitalOcean VPS running Weaviate in Docker. OpenAI embedding API at $0.02/1K tokens — roughly $5-$15/month for a mid-sized document corpus.

At 4 clients, monthly retainer revenue: $1,200-$3,200. Annual with setup fees: $26,000-$68,000. This is a solo-operator business model that works.

Path 2: Pinecone-to-Weaviate Migration

Pinecone Standard at 10M vectors costs ~$700/month. A self-hosted Weaviate instance handling the same workload costs ~$80/month. That is an $620/month savings — or $7,440/year — for the client.

A migration takes 3-5 days: export Pinecone vectors, set up Weaviate schema, configure hybrid search parameters, rebuild application queries, test, deploy. Charge $2,000-$5,000 per migration. The client recovers the cost in 3-8 months. You make a week's revenue in a week.

I have done three of these. The technical work is straightforward — the hard part is convincing the client that "cheaper" does not mean "worse." Bring latency benchmarks and be ready to explain hybrid search to a CTO who only knows keyword search.

Path 3: Managed Weaviate Hosting

If you have DevOps skills, spin up a dedicated server (Hetzner EX44 at $47/month gets you a Ryzen 5 3600 with 64GB RAM), run Weaviate with multi-tenancy, and host 8-15 small clients on a single machine.

Charge $200-$500/month per client for managed hosting (includes monitoring, backups, version upgrades). At 10 clients at $300/month: $3,000/month revenue against $100-$150/month total infrastructure cost.

The key to making this work: strict resource isolation between tenants. One client ingesting 500K vectors should not degrade latency for the other nine. Weaviate's class-level multi-tenancy handles this, but you need to monitor and set limits.

---

What Weaviate Is Bad At

I have been using Weaviate long enough to know where it hurts. Here is the honest list:

1. Large-scale cluster management is not plug-and-play. The default Docker Compose setup works for up to 20-30M vectors. Beyond that, you need to plan shards, configure replication, and tune the HNSW graph parameters. The documentation covers the knobs but does not tell you what happens when you turn them wrong. Expect a week of trial and error for production-scale deployments.

2. The GraphQL learning curve is real. If your team only knows REST APIs, the first week with GraphQL syntax will be painful. Queries that are one line in Pinecone's Python client become 15-line GraphQL documents. The power is worth it, but the ramp-up friction costs real time.

3. Module-based vectorizers create a dependency chain. When OpenAI has an outage, your Weaviate instance stops embedding new data. The modules are convenient but they tie your database's availability to external APIs. Mitigation: generate embeddings in a separate pipeline and use text2vec-none — but that defeats the convenience argument.

4. Cloud pricing opacity. WCS (Weaviate Cloud Services) pricing is clear at the low end (serverless starts at $25/month) but gets fuzzy at scale. The 25M+ vector tier requires you to talk to sales. For comparison, Pinecone publishes pricing up to 100M vectors. If you are building a business on WCS, you cannot model costs beyond the starter tier without a sales call.

5. Go ecosystem = fewer community modules. Weaviate is written in Go. The Python client is solid, but the broader integration ecosystem (LangChain, LlamaIndex, Haystack plugins) is thinner than Pinecone's or Qdrant's. Not a dealbreaker, but expect to write a few adapters yourself.

---

Weaviate vs the Competition: Quick Comparison

The summary: if you need GraphQL, built-in embeddings, or best-in-class hybrid search, Weaviate is the pick. If you need Rust performance and the simplest deployment story, look at Qdrant. If you need massive scale (100M+ vectors), Milvus handles it better. If you have money and zero DevOps capacity, Pinecone is the correct answer.

---

Getting Started Without Wasting Time

• Start with the Docker Compose one-liner, not the WCS cloud. You need to understand how Weaviate works before you outsource it. The local Docker setup takes 2 minutes and gives you full control for learning.

• Use text2vec-openai with the small model for prototyping. text-embedding-3-small at 512 dimensions gives you 90% of the quality at 25% of the cost and 40% of the latency. Switch to 1536 dimensions only when search quality testing shows you need it.

• Benchmark hybrid search with alpha=0.5, 0.75, and 1.0 on your actual data. The default fusion algorithm works differently for different document types. Legal documents (keyword-heavy) want alpha closer to 0.3. Marketing content (topic-heavy) wants alpha closer to 0.75. Do not guess.

• Set up monitoring before you launch. Weaviate exposes Prometheus metrics on port 2112. Track query latency (p50 and p95), import throughput, and memory usage. You will thank yourself when something breaks at 2 AM.

• Plan your schema carefully — migrations are manual. Weaviate does not have auto-migration. Changing a class definition after data is in it means exporting, dropping, recreating, and re-importing. Spend an extra hour on schema design up front.

• If you are building a SaaS on top of Weaviate, use tenant-level isolation from day one. It is one config flag in the schema. Adding it later requires a full reimport. Do not learn this the hard way like I did.

---

The Bottom Line

Weaviate is the vector database you pick when GraphQL matters, hybrid search is non-negotiable, and you want the option to self-host without vendor lock-in. It is not the fastest (Qdrant wins on raw speed), not the cheapest at scale (self-hosted Milvus scales better), and not the easiest to start with (Pinecone takes that crown).

What it is: the most thoughtfully designed vector database from a developer experience standpoint. The GraphQL API, the built-in modules, and the hybrid search fusion engine feel designed by people who actually build search applications, not database vendors who added vector search as a checkbox feature.

For a solo consultant or small agency building RAG systems and semantic search products, Weaviate hits the sweet spot: open-source so your business model is not shackled to a vendor's pricing page, powerful enough for production, and differentiated enough that clients see "GraphQL-native vector search" and understand they are getting something not every consultant can deliver. That is the money angle — and it works.