Migrate Pinecone to Qdrant: Complete Migration Guide | Zero Heart Burns

Okay so… you opened a bill from Pinecone and did a double-take. Or you tried to self-host it and discovered that’s just not a thing Pinecone lets you do. Or maybe you hit the 40KB metadata limit mid-sprint and your whole architecture needed a rethink. Whatever the reason might be you’re here, you want to move your vectors, and you want to do it without a disaster. I’ve been through this migration. Here’s everything I wish someone had told me before I started. Why You’re Even Reading This Here’s the thing about Pinecone… it’s genuinely easy to get started with. The docs are everywhere in AI tutorials, the API is clean, and you can have vectors in the cloud in like 20 minutes. That’s why so many teams start there. But then production hits… The cost curve surprises you. Pinecone’s serverless model charges per read unit, so every query costs money. At moderate QPS (say 500 queries per second), that meter is spinning fast. One team I talked to went from a comfortable $200/month in early testing to over $2k/month once their app got traction. The data doesn’t really get bigger, but the bills do. Vendor lock-in is real. Here’s a thing that quietly terrifies me: Pinecone has no export API. Like, none. You cannot say “give me all my vectors as a file.” If you want your data back, you have to iterate through IDs and fetch them back one batch at a time, and that only works on serverless indexes. Pod-based indexes? No list API at all. Pretty wild right? Namespace limits sneak up on you. Pinecone namespaces are a nice partitioning primitive but you’re capped at 100,000 namespaces on Standard. If you’re building a multi-tenant SaaS where each user has their own vector space… yeah, that can get uncomfortable fast. Metadata is flat and limited. 40KB per record, no nested JSON, no geo-coordinates, no full-text search on metadata fields. Need to store a document’s full text alongside its embedding? You’ll be doing a lot of creative truncation. No self-hosting, ever. This one is fundamental. Pinecone is SaaS-only. There is no Docker image, no Kubernetes operator, no “run it on your own machine” option. For teams with data residency requirements, regulated industries, or just a preference for not being dependent on external infrastructure… this is a hard blocker. The lightbulb moment for most developers is when they run Qdrant locally with docker run -p 6333:6333 qdrant/qdrant and realize it's the same thing - same API, same capabilities, same performance - but it's just... there, on your machine, completely under your control. Here’s the shape of this migration so you know what you’re getting into: Export your Pinecone data to a local JSONL file Spin up Qdrant locally or on Qdrant Cloud Load the data in and verify it If you’re in production: run dual-write while you migrate, then cut over with zero downtime Nothing here is magic. It’s just a bit of Python and some patience. The Mental Model Shift Before touching any code, let’s map the concepts. This is reference material to skim it now, come back when something breaks. Core Concept Mapping The namespace decision is actually important. You have two options: Separate collection per namespace: great if you have a small number of large namespaces and want clean isolation Single collection with a namespace payload field - better if you have many small namespaces, or want cross-namespace queries For most Pinecone migrations I’d go with option B (payload field), because collections have a recommended cap around 1,000 in Qdrant, and many Pinecone users have way more namespaces than that. Distance Metric Mapping # Pinecone metric values -> Qdrant Distance enum METRIC_MAP = { "cosine": Distance.COSINE, "euclidean": Distance.EUCLID, "dotproduct": Distance.DOT, } # Qdrant also has Distance.MANHATTAN - no Pinecone equivalent One gotcha here: Pinecone rescales cosine similarity to [0, 1]. Qdrant returns [-1, 1]. The rankings are identical, but any code that thresholds on raw score values will behave differently. Keep this in mind when you port your search logic. Filter Syntax from Before and After # === PINECONE === results = index.query( vector=[0.1] * 1536, filter={ "$and": [ {"genre": {"$eq": "sci-fi"}}, {"year": {"$gte": 2020}}, {"tags": {"$in": ["ai", "robots"]}} ] }, top_k=10, namespace="my-namespace", include_metadata=True ) matches = results["matches"] # list of {id, score, metadata} # === QDRANT === from qdrant_client.models import Filter, FieldCondition, MatchValue, MatchAny, Range results = client.search( collection_name="my_collection", query_vector=[0.1] * 1536, query_filter=Filter( must=[ FieldCondition(key="genre", match=MatchValue(value="sci-fi")), FieldCondition(key="year", range=Range(gte=2020)), FieldCondition(key="tags", match=MatchAny(any=["ai", "robots"])), # If you're using the payload-field namespace strategy: FieldCondition(key="_namespace", match=MatchValue(value="my-namespace")), ] ), limit=10, with_payload=True ) # results is a list of ScoredPoint objects with .id, .score, .payload The filter mapping rule of thumb: $and maps to must, $or maps to should, $ne maps to must_not. Numeric ranges map directly. $in maps to MatchAny. Honestly pretty intuitive once you see it side by side. Sparse + Dense Hybrid Pinecone hybrid search uses a single alpha parameter (0 = pure sparse, 1 = pure dense, linear blend). Qdrant uses explicit prefetch legs and rank fusion - either RRF (Reciprocal Rank Fusion) or DBSF. More code to write, but dramatically more control over how the fusion behaves. You can weight each leg independently, which ends up being pretty important for production tuning. Getting Your Data Out of Pinecone Here’s the honest truth: Pinecone has no export feature. No “Download All Data” button, no export endpoint, no snapshot you can take away. The only way out is to iterate through vector IDs and fetch them back in batches. The approach: Call list() to page through all vector IDs in a namespace (returns 100 IDs per page) For each page of IDs, call fetch() to get the actual vectors + metadata (up to 1,000 IDs per call) Write everything to a JSONL file One more thing before the code: this only works on serverless indexes . Pod-based indexes have no list API at all. If you're on a pod-based index... the only real option is to re-embed from your original document source, because there's no supported way to bulk-export from a pod index. Yikes. Rate limits to know: list is 200 req/s, fetch is 100 req/s. With 1,000 IDs per fetch call, that's theoretically 100,000 vectors per second. In practice, you'll be slower because of network and parsing overhead - but you won't hit limits if you stay around 10 concurrent fetch calls. Here’s a complete, resumable Pinecone exporter: #!/usr/bin/env python3 # VIBE CODED for smooth and quick setups """ pinecone_dumper.py Exports all vectors from a Pinecone serverless index to a JSONL file. Resumable: if interrupted, just rerun - it will pick up from where it left off. Requirements: pip install pinecone>=3.0.0 tqdm Usage: python pinecone_dumper.py \ --api-key pcsk_XXX \ --index-name my-index \ --output vectors.jsonl """ import argparse import json import os import time import math import pickle from pathlib import Path from pinecone import Pinecone from tqdm import tqdm LIST_BATCH_SIZE = 100 # Pinecone max IDs per list page FETCH_BATCH_SIZE = 1000 # Pinecone max IDs per fetch call FETCH_RATE_SLEEP = 0.011 # ~90 req/s, safely under 100 req/s limit def load_checkpoint(ckpt_path: str) -> dict: if Path(ckpt_path).exists(): with open(ckpt_path, "rb") as f: return pickle.load(f) return {} def save_checkpoint(ckpt_path: str, data: dict): tmp = ckpt_path + ".tmp" with open(tmp, "wb") as f: pickle.dump(data, f) os.replace(tmp, ckpt_path) def list_all_ids(index, namespace: str, checkpoint: dict, ckpt_path: str) -> list: ckpt_key = f"ids:{namespace}" if ckpt_key in checkpoint: print(f" Resuming ID listing for namespace='{namespace}' from checkpoint...") return checkpoint[ckpt_key] all_ids = [] cursor = None page_num = 0 print(f" Listing IDs for namespace='{namespace}'...") while True: kwargs = {"limit": LIST_BATCH_SIZE, "namespace": namespace} if cursor: kwargs["pagination_token"] = cursor try: resp = index.list_paginated(**kwargs) except Exception as e: print(f" ERROR listing page {page_num}: {e}. Retrying in 5s...") time.sleep(5) continue page_ids = [v.id for v in (resp.vectors or [])] all_ids.extend(page_ids) page_num += 1 if page_num % 100 == 0: print(f" ... {len(all_ids):,} IDs listed so far") cursor = resp.pagination.next if resp.pagination else None if not cursor: break print(f" Found {len(all_ids):,} IDs in namespace='{namespace}'") checkpoint[ckpt_key] = all_ids save_checkpoint(ckpt_path, checkpoint) return all_ids def fetch_and_write(index, all_ids, namespace, output_file, checkpoint, ckpt_path): ckpt_key = f"fetched_batches:{namespace}" completed_batches = checkpoint.get(ckpt_key, set()) total_batches = math.ceil(len(all_ids) / FETCH_BATCH_SIZE) new_writes = 0 with tqdm(total=len(all_ids), desc=f" Fetching vectors (ns='{namespace}')") as pbar: for batch_idx in range(total_batches): start = batch_idx * FETCH_BATCH_SIZE batch_ids = all_ids[start:start + FETCH_BATCH_SIZE] if batch_idx in completed_batches: pbar.update(len(batch_ids)) continue # Fetch with exponential backoff retry for attempt in range(5): try: resp = index.fetch(ids=batch_ids, namespace=namespace) break except Exception as e: wait = 2 ** attempt print(f"\n Fetch attempt {attempt+1} failed: {e}. Waiting {wait}s...") time.sleep(wait) else: print(f"\n ERROR: Could not fetch batch {batch_idx}. Skipping.") pbar.update(len(batch_ids)) continue vectors_map = resp.get("vectors", {}) for pid, pdata in vectors_map.items(): record = { "id": pid, "values": pdata.get("values", []), "metadata": pdata.get("metadata", {}), "_namespace": namespace, } sv = pdata.get("sparse_values") or pdata.get("sparseValues") if sv: record["sparse_values"] = { "indices": sv.get("indices", []), "values": sv.get("values", []), } output_file.write(json.dumps(record) + "\n") new_writes += 1 completed_batches.add(batch_idx) if batch_idx % 10 == 0: checkpoint[ckpt_key] = completed_batches save_checkpoint(ckpt_path, checkpoint) pbar.update(len(batch_ids)) time.sleep(FETCH_RATE_SLEEP) checkpoint[ckpt_key] = completed_batches save_checkpoint(ckpt_path, checkpoint) return new_writes def main(): parser = argparse.ArgumentParser(description="Export Pinecone index to JSONL") parser.add_argument("--api-key", required=True) parser.add_argument("--index-name", required=True) parser.add_argument("--index-host", default=None, help="Index host URL (optional, faster)") parser.add_argument("--namespace", default=None, help="Export one namespace only") parser.add_argument("--output", default="pinecone_export.jsonl") parser.add_argument("--checkpoint", default="pinecone_dump_checkpoint.pkl") parser.add_argument("--fresh", action="store_true", help="Ignore existing checkpoint") args = parser.parse_args() pc = Pinecone(api_key=args.api_key) index = pc.Index(host=args.index_host) if args.index_host else pc.Index(args.index_name) stats = index.describe_index_stats() namespaces = list(stats.get("namespaces", {}).keys()) if not namespaces: namespaces = [""] # default namespace if args.namespace: namespaces = [args.namespace] total_vectors = stats.get("total_vector_count", 0) dimension = stats.get("dimension", "unknown") print(f"\nIndex: {args.index_name}") print(f" Dimension: {dimension}") print(f" Total vectors: {total_vectors:,}") print(f" Namespaces: {namespaces}") print(f" Output: {args.output}\n") checkpoint = {} if args.fresh else load_checkpoint(args.checkpoint) total_written = 0 with open(args.output, "a", encoding="utf-8") as out_f: for ns in namespaces: print(f"Exporting namespace='{ns}'...") ids = list_all_ids(index, ns, checkpoint, args.checkpoint) written = fetch_and_write(index, ids, ns, out_f, checkpoint, args.checkpoint) total_written += written print(f" Done. {written:,} vectors written.\n") print(f"Export complete! Total: {total_written:,} vectors -> {args.output}") print(f"\nNext step: python qdrant_uploader.py --input {args.output}") if __name__ == "__main__": main() Run it like this: pip install "pinecone>=3.0.0" tqdm python pinecone_dumper.py \ --api-key pcsk_YOUR_KEY \ --index-name my-index \ --output my_vectors.jsonl If it gets interrupted mid-run, just run it again …. it’ll skip everything it already fetched. The checkpoint file tracks progress at the batch level so you don’t re-fetch things you already have. For very large indexes (100M+ vectors), this will take a while. The math: at 1,000 vectors per fetch and ~90 requests per second, you’re looking at roughly 90,000 vectors per second throughput. 100M vectors = ~18 minutes of pure fetch time, plus listing time on top. Run it overnight. Loading Into Qdrant (Local + Cloud) Okay, you’ve got your my_vectors.jsonl file. Now let's get it into Qdrant. Step 1: Start Qdrant locally docker run -d --name qdrant \ -p 6333:6333 -p 6334:6334 \ -v $(pwd)/qdrant_storage:/qdrant/storage \ qdrant/qdrant The web UI is at http://localhost:6333/dashboard. It's actually quite nice - you can browse collections, run test queries, inspect points. Better than nothing! Step 2: Recreate your collection You need the dimension and metric from your Pinecone index. The describe_index_stats() call doesn't return the metric (annoyingly) - check your index creation code or the Pinecone console. from qdrant_client import QdrantClient from qdrant_client.models import ( Distance, VectorParams, SparseVectorParams, HnswConfigDiff, OptimizersConfigDiff ) client = QdrantClient(url="http://localhost:6333") # For Qdrant Cloud: # client = QdrantClient( # url="https://YOUR-CLUSTER.cloud.qdrant.io", # api_key="YOUR_QDRANT_API_KEY" # ) COLLECTION = "my_collection" DIMENSION = 1536 # match your Pinecone index dimension METRIC = "cosine" METRIC_MAP = { "cosine": Distance.COSINE, "euclidean": Distance.EUCLID, "dotproduct": Distance.DOT, } # Disable HNSW during bulk load - re-enable after (3-5x faster ingest) client.create_collection( collection_name=COLLECTION, vectors_config=VectorParams(size=DIMENSION, distance=METRIC_MAP[METRIC]), optimizers_config=OptimizersConfigDiff(indexing_threshold=0), ) print(f"Created collection '{COLLECTION}'") Notice indexing_threshold=0 - that disables HNSW index building during the bulk load. We'll re-enable it after. This makes loading 3-5x faster because Qdrant isn't trying to build the graph while you're flooding it with vectors. Step 3: The uploader script #!/usr/bin/env python3 # Once again, have vibe coded this part to perfection! """ qdrant_uploader.py Reads a JSONL file from pinecone_dumper.py and bulk-upserts into Qdrant. Handles ID translation, batching, retries, and progress tracking. Requirements: pip install "qdrant-client>=1.9.0" tqdm Usage: python qdrant_uploader.py \ --input vectors.jsonl \ --collection my_collection \ --qdrant-url http://localhost:6333 """ import argparse import json import hashlib import time from pathlib import Path from qdrant_client import QdrantClient from qdrant_client.models import ( PointStruct, SparseVector, Distance, VectorParams, OptimizersConfigDiff, UpdateStatus ) from tqdm import tqdm UPSERT_BATCH_SIZE = 512 # 256-512 is the sweet spot MAX_RETRIES = 5 def pinecone_id_to_qdrant(pinecone_id: str) -> str: """ Convert a Pinecone string ID to a deterministic UUID for Qdrant. We store the original ID in payload as _pinecone_id for reverse lookup. """ h = hashlib.sha256(pinecone_id.encode()).hexdigest() return f"{h[:8]}-{h[8:12]}-{h[12:16]}-{h[16:20]}-{h[20:32]}" def count_lines(filepath: str) -> int: count = 0 with open(filepath, "rb") as f: for _ in f: count += 1 return count def upsert_batch_with_retry(client, collection, points, max_retries=MAX_RETRIES): for attempt in range(max_retries): try: result = client.upsert( collection_name=collection, points=points, wait=True, ) return result.status == UpdateStatus.COMPLETED except Exception as e: wait = 2 ** attempt print(f"\n Upsert attempt {attempt+1} failed: {e}. Waiting {wait}s...") time.sleep(wait) print(f"\n ERROR: Batch failed after {max_retries} retries. Skipping {len(points)} points.") return False def build_point(record: dict, has_sparse: bool) -> PointStruct: pinecone_id = record["id"] qdrant_id = pinecone_id_to_qdrant(pinecone_id) values = record.get("values", []) payload = dict(record.get("metadata", {})) payload["_pinecone_id"] = pinecone_id payload["_namespace"] = record.get("_namespace", "") if has_sparse and "sparse_values" in record: sv = record["sparse_values"] vector = { "dense": values, "sparse": SparseVector( indices=sv.get("indices", []), values=sv.get("values", []) ) } else: vector = values return PointStruct(id=qdrant_id, vector=vector, payload=payload) def main(): parser = argparse.ArgumentParser(description="Upload JSONL to Qdrant") parser.add_argument("--input", required=True) parser.add_argument("--collection", required=True) parser.add_argument("--qdrant-url", default="http://localhost:6333") parser.add_argument("--api-key", default=None, help="Qdrant API key (for cloud)") parser.add_argument("--has-sparse", action="store_true") parser.add_argument("--batch-size", type=int, default=UPSERT_BATCH_SIZE) args = parser.parse_args() client = QdrantClient(url=args.qdrant_url, api_key=args.api_key) try: info = client.get_collection(args.collection) print(f"Collection '{args.collection}' found - {info.vectors_count or 0:,} existing vectors") except Exception: print(f"ERROR: Collection '{args.collection}' not found. Create it first.") return total_lines = count_lines(args.input) print(f"\nInput file: {args.input} ({total_lines:,} records)") print(f"Batch size: {args.batch_size}\n") batch = [] total_uploaded = 0 total_failed = 0 with open(args.input, "r", encoding="utf-8") as f, \ tqdm(total=total_lines, desc="Uploading", unit="vec") as pbar: for line in f: line = line.strip() if not line: continue try: record = json.loads(line) except json.JSONDecodeError as e: print(f"\n Bad JSON line: {e}. Skipping.") pbar.update(1) continue batch.append(build_point(record, args.has_sparse)) if len(batch) >= args.batch_size: ok = upsert_batch_with_retry(client, args.collection, batch) if ok: total_uploaded += len(batch) else: total_failed += len(batch) pbar.update(len(batch)) batch = [] if batch: ok = upsert_batch_with_retry(client, args.collection, batch) total_uploaded += len(batch) if ok else 0 total_failed += len(batch) if not ok else 0 pbar.update(len(batch)) print(f"\nUpload complete! Uploaded: {total_uploaded:,} Failed: {total_failed:,}") # Re-enable HNSW indexing now that bulk load is done print("\nRe-enabling HNSW indexing...") client.update_collection( collection_name=args.collection, optimizers_config=OptimizersConfigDiff(indexing_threshold=20_000), ) print("Waiting for index to build (this may take a few minutes)...") while True: info = client.get_collection(args.collection) status = str(info.status).lower() if "green" in status: break print(f" Status: {status}... waiting 15s") time.sleep(15) final_count = client.get_collection(args.collection).vectors_count print(f"\nCollection '{args.collection}' is ready! Vector count: {final_count:,}") if __name__ == "__main__": main() Run the full pipeline: pip install "qdrant-client>=1.9.0" tqdm # 1. Export from Pinecone python pinecone_dumper.py --api-key pcsk_XXX --index-name my-index --output vectors.jsonl # 2. Upload to local Qdrant python qdrant_uploader.py \ --input vectors.jsonl \ --collection my_collection \ --qdrant-url http://localhost:6333 For Qdrant Cloud : sign up here , create a cluster (the free tier gets you 1M vectors permanently), then use: python qdrant_uploader.py \ --input vectors.jsonl \ --collection my_collection \ --qdrant-url https://YOUR-CLUSTER.cloud.qdrant.io \ --api-key YOUR_QDRANT_KEY Step 4: Verify it worked from qdrant_client import QdrantClient client = QdrantClient(url="http://localhost:6333") # Exact count (Qdrant's vectors_count is approximate for large collections) def exact_count(client, collection): count, offset = 0, None while True: recs, next_offset = client.scroll( collection_name=collection, limit=1000, offset=offset, with_payload=False, with_vectors=False ) count += len(recs) offset = next_offset if offset is None: break return count n = exact_count(client, "my_collection") print(f"Qdrant has {n:,} vectors") # Spot-check: search and print original Pinecone IDs from payload test_vec = [0.1] * 1536 # replace with a real vector results = client.search("my_collection", query_vector=test_vec, limit=5, with_payload=True) for r in results: print(f" score={r.score:.4f} original_pinecone_id={r.payload.get('_pinecone_id')}") One more option: Qdrant’s official migration tool Qdrant ships a Docker-based migration CLI that handles Pinecone directly. For serverless indexes, one command does the whole thing: docker run --rm -it registry.cloud.qdrant.io/library/qdrant-migration pinecone \ --pinecone.index-host 'https://your-index.svc.pinecone.io' \ --pinecone.index-name 'your-index' \ --pinecone.api-key 'pcsk_...' \ --qdrant.url 'https://your-cluster.cloud.qdrant.io:6334' \ --qdrant.api-key 'your-qdrant-key' \ --qdrant.collection 'your-collection' \ --migration.batch-size 64 Note the gRPC port (6334): the migration tool uses gRPC, not the REST API. And it’s resumable via an internal _migration_offsets collection it creates on the target. If it gets killed, just rerun and it picks up from the last offset. Zero Downtime Migration (The Production Way) If you’re running a live production service on Pinecone, you can’t just turn it off run the migration and turn it back on. Here’s how to do it with zero downtime. The core idea: run both databases simultaneously. Pinecone stays primary for reads. Qdrant gets all the writes. Once Qdrant has all the historical data and has proven itself with real traffic, you flip the switch. The Dual-Write Wrapper import threading from concurrent.futures import ThreadPoolExecutor from queue import Queue, Empty class DualWriteClient: """ Wrap your existing Pinecone index to simultaneously write to Qdrant. Pinecone is primary (writes block on Pinecone success). Qdrant writes are async and non-blocking - failures queue for retry. """ def __init__(self, pinecone_idx, qdrant_client, qdrant_collection): self.pine = pinecone_idx self.qdrant = qdrant_client self.col = qdrant_collection self.pool = ThreadPoolExecutor(max_workers=4, thread_name_prefix="qdrant-write") self.retry_q = Queue(maxsize=10_000) self._start_retry_worker() def upsert(self, vectors, namespace=""): # Step 1: Write to Pinecone (primary, blocks until confirmed) self.pine.upsert(vectors=vectors, namespace=namespace) # Step 2: Write to Qdrant async (never blocks your app) self.pool.submit(self._qdrant_upsert, vectors, namespace) def _qdrant_upsert(self, vectors, namespace): from qdrant_client.models import PointStruct points = [ PointStruct( id=pinecone_id_to_qdrant(v["id"]), vector=v["values"], payload={**v.get("metadata", {}), "_pinecone_id": v["id"], "_namespace": namespace} ) for v in vectors ] try: self.qdrant.upsert(collection_name=self.col, points=points, wait=True) except Exception as e: print(f"Qdrant write failed, queuing retry: {e}") try: self.retry_q.put_nowait(("upsert", points)) except Exception: print(f"Retry queue full - {len(points)} points dropped") def delete(self, ids, namespace=""): self.pine.delete(ids=ids, namespace=namespace) qdrant_ids = [pinecone_id_to_qdrant(i) for i in ids] self.pool.submit(self._qdrant_delete, qdrant_ids) def _qdrant_delete(self, ids): try: self.qdrant.delete(collection_name=self.col, points_selector=ids, wait=True) except Exception as e: try: self.retry_q.put_nowait(("delete", ids)) except Exception: pass def _start_retry_worker(self): t = threading.Thread(target=self._retry_loop, daemon=True) t.start() def _retry_loop(self): while True: try: op, payload = self.retry_q.get(timeout=5) except Empty: continue for attempt in range(5): try: if op == "upsert": self.qdrant.upsert(collection_name=self.col, points=payload, wait=True) else: self.qdrant.delete(collection_name=self.col, points_selector=payload, wait=True) break except Exception: time.sleep(2 ** attempt) # Usage: replace your existing pinecone_index with this one line # Before: results = pinecone_index.query(...) # After: results = dual_client.pine.query(...) <- reads still go to Pinecone # # dual_client = DualWriteClient(pc.Index("my-index"), qdrant_client, "my_collection") # dual_client.upsert(vectors=[...]) <- writes go to both The Migration Timeline Once dual-write is running, here’s the sequence: Start dual-write : your app now writes to both. Reads still come from Pinecone. Run the backfill: use the dumper + uploader scripts from Sections 3–4 to migrate historical data. Dual-write handles anything new that comes in while the backfill runs. Shadow mode: for a day or two, run every search query against Qdrant too (don’t show results to users yet), compare rankings, log quality differences. Cutover: once you’re happy with quality parity, flip the read traffic. Cutover Checklist Before you switch traffic to Qdrant: JUST VERI FY the following okay? [x] Dual-write has been running >= 48 hours without errors [x] Backfill complete - Qdrant vector count within 0.1% of Pinecone count [x] Shadow comparison: mean Recall@10 >= 0.95 over at least 10,000 queries [x] Qdrant collection status = green (fully indexed) [x] P99 search latency on Qdrant within 15% of Pinecone [x] Rollback plan tested - know how to re-enable Pinecone reads in under 5 minutes The Atomic Cutover (Qdrant Aliases) Qdrant has collection aliases so that a single API call switches an alias from one collection to another with zero gap. Use this for the cutover: from qdrant_client.models import CreateAliasOperation, DeleteAliasOperation # One API call - no window where the alias is undefined qdrant_client.update_collection_aliases( change_aliases_operations=[ DeleteAliasOperation(delete_alias={"alias_name": "production"}), CreateAliasOperation(create_alias={ "collection_name": "my_collection", "alias_name": "production" }), ] ) # From this point: all reads going to "production" alias hit Qdrant Rollback Plan Keep dual-write running for at least 48 hours after full cutover. If something goes wrong, rollback is literally just updating a feature flag or load balancer weight to send reads back to Pinecone. Since dual-write is still active, Pinecone stays in sync during that window. Rolling back is instant and safe. Why Qdrant Cloud Hits Different Okay… so I’ve been pretty technical so far. Let me just talk about what actually feels different when you’re using Qdrant versus Pinecone day-to-day. The free tier is actually useful. Qdrant Cloud’s free tier is permanent and not a trial, and supports roughly 1M vectors on a real cluster (0.5 vCPU, 1 GB RAM, 4 GB disk)!!!!!! Pinecone’s free tier is 100,000 vectors on a single serverless index with the per-read-unit billing lurking. Qdrant’s free tier is just… a free cluster. No gotchas, no time limit. NOTABLE MENTIONS FROM MY RESEARCH AND DUMP BELOW! You can actually run it yourself. docker run -p 6333:6333 qdrant/qdrant. That's it. The self-hosted version and the cloud version run the same binary. No features are gated behind cloud-only access. The API is identical everywhere. You can move between local development, your own Kubernetes cluster, and Qdrant Cloud at any time. Your data is portable. Your skills transfer. Pinecone is SaaS-only, period. Quantization is a superpower. Pinecone stores everything as float32. That’s 4 bytes per dimension, no exceptions. For a 10M vector / 1536-dim collection, that’s ~61 GB of raw vector data. With Qdrant’s Turbo4 4-bit datatype (from v1.19), you get that down to ~7.6 GB while maintaining solid recall. With binary quantization you’re under 2 GB. This is roughly a 30x memory reduction. At $5/GB/month in cloud RAM costs, that’s a very large number. Quick cost comparison for 10M vectors at 1536 dims Filterable HNSW is a real algorithmic difference. Pinecone applies filters as pre-filter or post-filter. If your filter is very selective (say, filter to 1% of vectors), post-filtering wastes a huge amount of graph traversal work, and pre-filtering with very small candidate sets loses recall. Qdrant integrates payload filtering directly into the HNSW graph traversal — it navigates the graph while respecting the filter in real-time. This gives predictable recall even on highly selective filters. It’s not a marketing claim — it’s a fundamentally different query execution model. Multi-vector per point. Each Qdrant point can have multiple named vectors. One point can carry a text embedding (768-dim), an image embedding (512-dim), and a sparse BM25 vector, all stored together with their payload. A single hybrid search can fuse all three with RRF. Pinecone gives you one vector per record. Full stop. This matters a lot for multimodal and hybrid retrieval workloads. Data portability is the anti-vendor-lock-in story. With Qdrant, you can snapshot any collection and download it: # Create a snapshot snapshot_info = client.create_snapshot(collection_name="my_collection") print(f"Snapshot: {snapshot_info.name}") # Download it (it's just an HTTP GET) # GET /collections/my_collection/snapshots/{snapshot_name} That snapshot is your data. You can restore it to any Qdrant instance anywhere. If Qdrant doubles their prices tomorrow, you have a complete copy of your data ready to move. With Pinecone, you do the LIST+FETCH dance described in Section 3. If Pinecone has an outage and you can’t list your IDs… well. Open source, for real. Qdrant has 34,000+ GitHub stars, Apache 2.0 license, and the team actively responds to issues. You can read the source code, understand exactly what’s happening with your data, file bugs, send PRs. When something weird happens with your search results, you can actually dig in and find out why. Pinecone is a black box. That distinction sounds abstract until something goes wrong. The Qdrant documentation covers all of this in depth — quantization options, memory tier configs, distributed deployment, the lot. And if you want to follow what’s coming next (new quantization research, benchmark results, engineering deep-dives), the newsletter is worth subscribing to. They publish real engineering content, not just product announcements. Alright now! that’s the full picture. The migration is doable okay and most teams do it over a week or two with zero downtime using the dual-write approach. The scripts handle the heavy lifting. The main gotchas to keep in mind: Pinecone has no export API: you’re doing LIST+FETCH, and that only works on serverless indexes Pod-based indexes need to be re-embedded from your original document source Cosine scores have different ranges ([0,1] in Pinecone, [-1,1] in Qdrant) - watch any code that thresholds on raw scores Keep dual-write running for 48 hours post-cutover before you decommission anything Good luck with the migration. You’ve got this. Migrate Pinecone to Qdrant: Complete Migration Guide | Zero Heart Burns was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.