Every vector database advertises a free tier. Very few of them tell you what that tier is actually good for.

A free cluster is usually where a RAG prototype, a semantic search demo, or an agent memory experiment begins, so the limits matter earlier than most people expect. How much text can you store before you hit the cap? Do you need a separate embedding provider just to ingest your first document? What happens to the cluster if you stop touching it for a week? And if the prototype works, can you take it somewhere else without rewriting it?

This guide compares three managed free tiers on those questions: Weaviate Cloud, Pinecone, and Qdrant Cloud. They are ranked in that order, and the sections below explain why.

What “free” really has to cover

Before the comparison, it helps to know where free tiers usually run out.

Storage is rarely about the vectors. A 1536-dimension float32 embedding takes about 6 KB, so 100,000 of them come to roughly 600 MB. In a real RAG pipeline the raw text chunks, transcripts, and metadata usually take far more space than the embeddings that point to them. A tier that sounds generous on vector count can still fill up quickly once you store the content you actually want to retrieve.

Memory decides how fast things feel. Vector indexes want to live in RAM. How a platform handles a small memory budget, through compression or disk-based indexing, determines how much data a free cluster can serve before latency changes.

Bundled AI saves the most setup time. Free embedding and query features remove an entire integration from your first afternoon: no second API key, no separate billing account, no glue code.

Portability is the quiet one. Code you write against a free cluster should not trap you there.

The three free tiers at a glance

Free-tier limits change often. Check each vendor’s pricing page before you commit to a design around a specific number.

1. Weaviate Cloud: the most room, and the most built in

Best for: production-minded RAG, multimodal search, and agent projects that need to store real text next to their vectors.

What the free tier includes

• 10 GB of persistent disk and 1 GB of RAM
• Up to 100,000 objects in one collection, with up to three tenants
• One free cluster per user, no credit card required
• 2,000 Weaviate Embeddings requests per day
• 1,000 Query Agent requests per month

Why it comes first

The storage is built for content, not just vectors. Spread across the 100,000-object cap, 10 GB leaves around 100 KB per object. That is enough to keep a full document chunk, its source metadata, and a transcript snippet together, which is exactly the shape of data a retrieval pipeline needs. It is five times Pinecone’s free storage and two and a half times Qdrant’s.

A small memory budget goes further than it looks. Free clusters run on the Cost Optimized profile, which uses HFresh, a disk-based, cluster-oriented index. Only a compressed centroid index has to stay in memory, while the posting lists live on disk. That design is what lets a 1 GB RAM allocation sit comfortably in front of a much larger disk. Weaviate also supports four vector compression methods (rotational, product, scalar, and binary quantization), with 8-bit rotational quantization as the recommended default and the default on Weaviate Cloud.

Embeddings happen inside the database. With a vectorizer configured on the collection (text2vec-* for text, multi2vec-* for images and other media), you send raw content and Weaviate generates the vectors for you, at write time and at query time. Weaviate Embeddings, the managed service, is free to try on a free cluster at 2,000 requests per day. With a maximum of 200 objects per batch, that works out to as many as 400,000 embeddings in a day. If you prefer another provider, integrations for OpenAI, Cohere, Hugging Face, Voyage AI, and others are available.

Search is not just vector search. A single query can combine vector similarity with BM25 keyword matching and metadata filters. Hybrid search runs both retrievers and fuses the results (relative score fusion is the default, ranked fusion is available), with an alpha parameter that sets how much weight each side gets.

There is a path from question to answer. The Query Agent turns natural-language questions into database queries, choosing collections, filters, and search types on its own. The free allowance is 1,000 requests per month, and a request is not always one question: a search costs one request, while an Ask query costs four. In practice that means up to 1,000 searches or 250 Ask queries a month.

Agents get a memory layer. Engram is Weaviate’s memory service for LLM and agent applications. Instead of piling raw chat logs into a vector collection, it stores user interactions and preferences as persistent, searchable memories that can personalize later conversations.

One embedding space, many media types. Multimodal vectorizers such as multi2vec-clip and multi2vec-bind place text, images, and other media in a shared vector space, so a text prompt can retrieve an image without extra middleware.

Objects can point at each other. Cross-references link objects across collections (an Article to its Author, for example) so related properties come back alongside vector or hybrid results. They really come into their own as your schema grows beyond the first collection.

Nothing locks you in. Weaviate is open source under BSD-3-Clause. The code you write for Weaviate Cloud runs the same against a local Docker container, a self-hosted Kubernetes cluster, or an air-gapped on-premise deployment.

Getting the most out of it

• One collection, up to three tenants. It is a focused starting point: keep all your content in a single collection and use a property to separate content types, or use the three tenants to keep users or projects apart.
• Keep the cluster active. The free cluster stays free as long as you use it. If it sits idle for 7 days it is paused with your data preserved, and you can reactivate it from the console whenever you like. A simple scheduled query keeps a demo running.
• Index tuning is handled for you. Free clusters come ready with HFresh as the default index, so there is nothing to configure: leave the vector index unset and your collection picks it up automatically.

2. Pinecone: the easiest to ignore

Best for: teams that want a hands-off, serverless vector index and have no interest in thinking about infrastructure.

What the Starter plan includes

• Up to 2 GB of total storage
• Up to 5 serverless indexes, each with up to 100 namespaces
• Up to 2 million write units and 1 million read units per month
• Pinecone Inference: 5 million embedding tokens per month and 500 rerank requests per month (bge-reranker-v2-m3)
• Pinecone Assistant: 1 GB of file storage, plus 500k input and 300k output tokens

Where it shines

Operations are almost nonexistent. There is no cluster to size, no index to tune, and capacity scales on demand within your quota. The monthly read and write allowances are generous for a prototype, and the built-in embedding and reranking endpoints mean a basic retrieve-and-rerank pipeline can run without a second vendor.

Where you will feel the limits

• 2 GB total storage is the tightest of the three tiers, and it goes quickly once you store full chunks and metadata rather than just vectors.
• One region. The free tier is limited to AWS us-east-1, which matters if data residency or latency to another region is a requirement.
• One project and two users per account.
• Closed-source SaaS. There is no self-hosted route, so moving later means changing both your database and the code written against its API.

3. Qdrant Cloud: compression-first, with tight compute

Best for: engineers who care about low latency, rich payload filtering, and squeezing as many vectors as possible out of a small footprint.

What the free tier includes

• 0.5 shared vCPU, 1 GB RAM, and 4 GB of disk
• Roughly 250,000 uncompressed 1536-dimension vectors, rising to 7–8 million with binary quantization (32× compression)
• A web UI dashboard, free cloud inference for selected models, payload indexing, and native hybrid search

Where it shines

Qdrant is a Rust engine with a strong reputation for fast, filter-heavy search, and its flexible JSON payloads make it easy to attach structured data to every vector. Binary and scalar quantization are first-class tools, and the capacity jump from compression is the most dramatic on this list: the same 1 GB of RAM goes from hundreds of thousands of vectors to millions.

Where you will feel the limits

• 4 GB of disk is less than half of Weaviate’s allowance, so stored text and metadata become the constraint before vector count does.
• A single shared half-vCPU limits how much concurrent load the cluster can take, even when the index itself fits comfortably in memory.
• Public endpoints only on the free tier.

How to choose

• You are building RAG over real documents and want the text, metadata, and vectors in one place: Weaviate Cloud. Storage is the deciding factor.
• You want no embedding pipeline at all: Weaviate Cloud (managed embeddings, in-database vectorization) or Pinecone (built-in inference).
• You want a serverless index and nothing else to manage, and your data fits in 2 GB: Pinecone.
• You need the most vectors from the least memory, and you are comfortable tuning quantization: Qdrant Cloud.
• You expect to move to self-hosting later (or have compliance reasons to keep that option open): Weaviate or Qdrant, both open source.
• You are experimenting with agent memory, not just retrieval: Weaviate Cloud, where Engram is part of the same platform.

Try Weaviate’s free tier in a few lines

Create a free cluster in the Weaviate Cloud console, then connect and query it with the Python client. The collection below lets Weaviate Embeddings handle vectorization, so there is no separate embedding provider to set up.

import os
    import weaviate
    from weaviate.classes.config import Configure

    with weaviate.connect_to_weaviate_cloud(
        cluster_url=os.environ["WEAVIATE_URL"],
        auth_credentials=os.environ["WEAVIATE_API_KEY"],
    ) as client:

        # Weaviate generates the vectors; no external embedding key needed
        docs = client.collections.create(
            name="Document",
            vector_config=Configure.Vectors.text2vec_weaviate(),
        )

        docs.data.ingest([
            {"title": "Chunking basics", "body": "Split source text into retrievable passages."},
            {"title": "Hybrid search", "body": "Blend semantic similarity with keyword matching."},
            {"title": "Agent memory", "body": "Store and retrieve what an agent learns over time."},
        ])

        # Hybrid query: vector similarity + BM25, weighted toward meaning
        response = docs.query.hybrid(
            query="how do I combine keyword and semantic search?",
            alpha=0.75,
            limit=2,
        )

        for obj in response.objects:
            print(obj.properties["title"])
    

Frequently asked questions

Which free vector database offers the most storage?
Weaviate Cloud, at 10 GB of persistent disk. Qdrant Cloud offers 4 GB and Pinecone’s Starter plan offers 2 GB.

Is Weaviate Cloud’s free tier really free forever?
Yes. The free cluster needs no credit card and has no expiry date. To keep it running, use it now and then: it pauses after 7 days of inactivity with your data preserved, and you can reactivate it from the console at any time. Clusters that stay inactive for 30 days are removed, so an occasional query is all it takes to keep yours.

Do I need a separate embedding provider to use a free vector database?
Not necessarily. Weaviate Cloud includes managed embeddings (2,000 requests per day on a free cluster) and in-database vectorization. Pinecone includes inference with a 5 million token monthly allowance. Qdrant Cloud includes free inference for selected models.

Can I move off a free tier later without rewriting my application?
It depends on the platform. Weaviate and Qdrant are open source, so you can self-host the same engine. Pinecone is a closed-source service, so leaving it means changing both the database and the code written against it.

Ready to start building?

Check out the Quickstart tutorial, compare plans on the pricing page, or create a free Weaviate Cloud cluster and have your first collection running in a few minutes.