Pinecone vs Weaviate vs Qdrant 2026: Vector Database Production Karşılaştırma

1# HNSW parametrelerinin etkisini anlama
2# 1536-dim OpenAI text-embedding-3-large vektörler için önerilen değerler
3 
4hnsw_config_balanced = {
5    "M": 16,              # Bellek-performans dengesi
6    "ef_construction": 128,  # İyi index kalitesi
7    "ef_search": 64,      # Hızlı query (~5ms p50)
8    "metric": "cosine"    # OpenAI embedding'ler için cosine similarity
9}
10 
11hnsw_config_high_recall = {
12    "M": 32,              # Daha fazla bağlantı = daha iyi recall
13    "ef_construction": 256,
14    "ef_search": 128,     # Yavaş ama doğru (~15ms p50)
15    "metric": "cosine"
16}
17 
18# Memory hesaplama: 1M vektör için
19# 1536 dim * 4 bytes (float32) * 1M vektör = ~6GB ham
20# HNSW overhead M=16 ile ~+2GB
21# Toplam: ~8GB RAM 1M vektör için

1from enum import Enum
2 
3class DistanceMetric(Enum):
4    COSINE = "cosine"      # Yön benzerliği - embedding'ler için default
5    DOT_PRODUCT = "dot"    # Normalized vektörler için cosine'le eşdeğer, daha hızlı
6    EUCLIDEAN = "euclidean"  # Mutlak mesafe - görüntü/ses için
7 
8# OpenAI, Cohere, Voyage AI embedding'ler: COSINE veya DOT_PRODUCT
9# Pixel vektörler: EUCLIDEAN
10# Multi-modal embedding'ler: üretici dokümantasyonunu kontrol edin

1from pinecone import Pinecone, ServerlessSpec
2import openai
3import numpy as np
4 
5# İstemci oluşturma
6pc = Pinecone(api_key="your-pinecone-api-key")
7 
8# Serverless index oluşturma (2026 önerilen mod)
9pc.create_index(
10    name="production-embeddings",
11    dimension=1536,  # text-embedding-3-small boyutu
12    metric="cosine",
13    spec=ServerlessSpec(
14        cloud="aws",
15        region="us-east-1"
16    )
17)
18 
19index = pc.Index("production-embeddings")
20 
21# Batch upsert - optimal performans için 100'lü batch'ler
22def batch_upsert_embeddings(documents: list[dict], batch_size: int = 100):
23    openai_client = openai.OpenAI()
24 
25    all_vectors = []
26    for doc in documents:
27        embedding = openai_client.embeddings.create(
28            model="text-embedding-3-small",
29            input=doc["text"]
30        ).data[0].embedding
31 
32        all_vectors.append({
33            "id": doc["id"],
34            "values": embedding,
35            "metadata": {
36                "text": doc["text"][:1000],  # Pinecone metadata limit: 40KB
37                "source": doc.get("source", ""),
38                "created_at": doc.get("created_at", ""),
39                "user_id": doc.get("user_id", ""),  # Multi-tenancy için
40                "category": doc.get("category", "")
41            }
42        })
43 
44    # Batch'ler halinde upsert
45    for i in range(0, len(all_vectors), batch_size):
46        batch = all_vectors[i:i + batch_size]
47        index.upsert(vectors=batch)
48        print(f"Upsert: {i + len(batch)}/{len(all_vectors)}")
49 
50# Metadata filtering ile query
51def query_with_filter(query_text: str, user_id: str, category: str = None):
52    openai_client = openai.OpenAI()
53 
54    query_embedding = openai_client.embeddings.create(
55        model="text-embedding-3-small",
56        input=query_text
57    ).data[0].embedding
58 
59    # Pinecone filter syntax
60    filter_dict = {"user_id": {"$eq": user_id}}
61    if category:
62        filter_dict["category"] = {"$in": [category, "general"]}
63 
64    results = index.query(
65        vector=query_embedding,
66        top_k=10,
67        filter=filter_dict,
68        include_metadata=True
69    )
70 
71    return [
72        {
73            "text": match.metadata["text"],
74            "score": match.score,
75            "id": match.id
76        }
77        for match in results.matches
78    ]

1# Namespace: tenant isolation için en temiz Pinecone pattern
2def upsert_for_tenant(tenant_id: str, vectors: list):
3    """Her tenant kendi namespace'inde izole"""
4    index.upsert(
5        vectors=vectors,
6        namespace=f"tenant_{tenant_id}"
7    )
8 
9def query_for_tenant(tenant_id: str, query_vector: list, top_k: int = 10):
10    return index.query(
11        vector=query_vector,
12        top_k=top_k,
13        namespace=f"tenant_{tenant_id}",
14        include_metadata=True
15    )
16 
17# Namespace silme - tenant offboarding
18def delete_tenant_data(tenant_id: str):
19    index.delete(delete_all=True, namespace=f"tenant_{tenant_id}")
20    print(f"Tenant {tenant_id} namespace silindi")

1import weaviate
2from weaviate.classes.init import Auth
3from weaviate.classes.config import Configure, Property, DataType, VectorDistances
4from weaviate.classes.query import MetadataQuery, Filter
5 
6# Weaviate Cloud bağlantısı
7client = weaviate.connect_to_weaviate_cloud(
8    cluster_url="https://your-cluster.weaviate.network",
9    auth_credentials=Auth.api_key("your-weaviate-api-key"),
10    headers={
11        "X-OpenAI-Api-Key": "your-openai-api-key"
12    }
13)
14 
15# Collection oluşturma (Weaviate v4 syntax)
16client.collections.create(
17    name="Document",
18    vectorizer_config=Configure.Vectorizer.text2vec_openai(
19        model="text-embedding-3-small",
20        dimensions=1536
21    ),
22    generative_config=Configure.Generative.openai(
23        model="gpt-4o-mini"
24    ),
25    reranker_config=Configure.Reranker.cohere(
26        model="rerank-english-v3.0"
27    ),
28    vector_index_config=Configure.VectorIndex.hnsw(
29        distance_metric=VectorDistances.COSINE,
30        ef_construction=128,
31        max_connections=16,
32        ef=64
33    ),
34    properties=[
35        Property(name="content", data_type=DataType.TEXT),
36        Property(name="source", data_type=DataType.TEXT),
37        Property(name="user_id", data_type=DataType.TEXT),
38        Property(name="category", data_type=DataType.TEXT),
39        Property(name="created_at", data_type=DataType.DATE),
40    ]
41)
42 
43collection = client.collections.get("Document")
44 
45# Batch insert
46with collection.batch.dynamic() as batch:
47    for doc in documents:
48        batch.add_object(
49            properties={
50                "content": doc["text"],
51                "source": doc["source"],
52                "user_id": doc["user_id"],
53                "category": doc["category"],
54            }
55        )
56 
57# Hybrid search (dense + sparse BM25)
58results = collection.query.hybrid(
59    query="vector database production deployment",
60    alpha=0.7,  # 0=pure BM25, 1=pure vector, 0.7=vector ağırlıklı
61    limit=10,
62    filters=Filter.by_property("user_id").equal("user_123"),
63    return_metadata=MetadataQuery(score=True, explain_score=True)
64)
65 
66for obj in results.objects:
67    print(f"Score: {obj.metadata.score:.4f} - {obj.properties['content'][:100]}")

1# Weaviate'in benzersiz özelliği: query sonuçlarını direkt LLM'e gönder
2response = collection.generate.near_text(
3    query="vector database nasıl seçilir?",
4    limit=5,
5    grouped_task="Bu sonuçlara dayanarak, startup için en uygun vector database hangisi ve neden? Türkçe yanıtla.",
6    grouped_properties=["content", "source"]
7)
8 
9print(response.generated)  # LLM'in birleşik yanıtı

1from qdrant_client import QdrantClient
2from qdrant_client.models import (
3    Distance, VectorParams, HnswConfigDiff,
4    PointStruct, Filter, FieldCondition, MatchValue,
5    PayloadSchemaType, SparseVectorParams, SparseIndexParams
6)
7 
8# Local veya cloud bağlantı
9client = QdrantClient(
10    url="https://your-cluster.qdrant.io",
11    api_key="your-qdrant-api-key"
12)
13 
14# Collection oluşturma - ince ayarlanmış HNSW
15client.create_collection(
16    collection_name="documents",
17    vectors_config=VectorParams(
18        size=1536,
19        distance=Distance.COSINE,
20        hnsw_config=HnswConfigDiff(
21            m=16,
22            ef_construct=128,
23            full_scan_threshold=10000  # Bu eşiğin altında brute-force
24        )
25    ),
26    # Sparse vektör (BM25 hybrid search için)
27    sparse_vectors_config={
28        "sparse": SparseVectorParams(
29            index=SparseIndexParams(on_disk=False)
30        )
31    }
32)
33 
34# Payload index oluşturma (filtreleme performansı için kritik!)
35client.create_payload_index(
36    collection_name="documents",
37    field_name="user_id",
38    field_schema=PayloadSchemaType.KEYWORD
39)
40client.create_payload_index(
41    collection_name="documents",
42    field_name="category",
43    field_schema=PayloadSchemaType.KEYWORD
44)
45client.create_payload_index(
46    collection_name="documents",
47    field_name="created_at",
48    field_schema=PayloadSchemaType.DATETIME
49)
50 
51# Batch upsert
52def qdrant_batch_upsert(vectors: list[list[float]], payloads: list[dict], ids: list[str]):
53    points = [
54        PointStruct(
55            id=i,  # Qdrant integer veya UUID ID ister
56            vector=vector,
57            payload=payload
58        )
59        for i, (vector, payload) in enumerate(zip(vectors, payloads))
60    ]
61 
62    # Qdrant batch size önerisi: 1000
63    batch_size = 1000
64    for i in range(0, len(points), batch_size):
65        client.upsert(
66            collection_name="documents",
67            points=points[i:i + batch_size],
68            wait=True  # Consistency için sync upsert
69        )
70        print(f"Qdrant upsert: {i + min(batch_size, len(points) - i)}/{len(points)}")
71 
72# Payload-based filtering ile query
73results = client.query_points(
74    collection_name="documents",
75    query=query_vector,
76    query_filter=Filter(
77        must=[
78            FieldCondition(
79                key="user_id",
80                match=MatchValue(value="user_123")
81            )
82        ],
83        should=[
84            FieldCondition(key="category", match=MatchValue(value="technical")),
85            FieldCondition(key="category", match=MatchValue(value="general")),
86        ]
87    ),
88    limit=10,
89    with_payload=True
90)

1from qdrant_client.models import Prefetch, Query, FusionQuery, Fusion
2from fastembed import SparseTextEmbedding
3 
4# Sparse embedding model (BM25 benzeri)
5sparse_model = SparseTextEmbedding(model_name="Qdrant/bm25")
6 
7def qdrant_hybrid_search(
8    query_text: str,
9    dense_vector: list[float],
10    user_id: str,
11    limit: int = 10
12):
13    sparse_embeddings = list(sparse_model.embed([query_text]))[0]
14 
15    results = client.query_points(
16        collection_name="documents",
17        prefetch=[
18            Prefetch(
19                query=dense_vector,
20                limit=100  # Dense'den 100 aday al
21            ),
22            Prefetch(
23                query=models.SparseVector(
24                    indices=sparse_embeddings.indices.tolist(),
25                    values=sparse_embeddings.values.tolist()
26                ),
27                using="sparse",
28                limit=100  # Sparse'den 100 aday al
29            ),
30        ],
31        query=FusionQuery(fusion=Fusion.RRF),  # Reciprocal Rank Fusion ile birleştir
32        query_filter=Filter(
33            must=[FieldCondition(key="user_id", match=MatchValue(value=user_id))]
34        ),
35        limit=limit,
36        with_payload=True
37    )
38 
39    return results.points

1# LangChain ile üç veritabanı için hybrid search
2from langchain_pinecone import PineconeVectorStore
3from langchain_openai import OpenAIEmbeddings
4from langchain_community.retrievers import PineconeHybridSearchRetriever
5from pinecone_text.sparse import BM25Encoder
6 
7# BM25 encoder eğitimi (corpus üzerinde)
8bm25_encoder = BM25Encoder()
9corpus_texts = [doc["text"] for doc in documents]
10bm25_encoder.fit(corpus_texts)
11bm25_encoder.dump("bm25_values.json")
12 
13# Pinecone Hybrid Search (index'te sparse vector desteği gerekli)
14hybrid_retriever = PineconeHybridSearchRetriever(
15    embeddings=OpenAIEmbeddings(model="text-embedding-3-small"),
16    sparse_encoder=BM25Encoder().load("bm25_values.json"),
17    index=pc.Index("hybrid-index"),
18    alpha=0.7,  # Semantic ağırlığı
19    top_k=10
20)
21 
22results = hybrid_retriever.get_relevant_documents(
23    "vector database HNSW configuration production"
24)

1# Pinecone metadata filter operatörleri
2pinecone_filter_examples = {
3    # Equality
4    "user_id": {"$eq": "user_123"},
5 
6    # Array contains
7    "tags": {"$in": ["python", "machine-learning"]},
8 
9    # Range (sayısal)
10    "score": {"$gte": 0.8, "$lte": 1.0},
11 
12    # AND kombinasyonu
13    "$and": [
14        {"user_id": {"$eq": "user_123"}},
15        {"category": {"$in": ["tech", "science"]}}
16    ],
17 
18    # NOT
19    "status": {"$ne": "deleted"}
20}

1from qdrant_client.models import Filter, FieldCondition, MatchValue, Range, DatetimeRange
2from datetime import datetime
3 
4# Qdrant gelişmiş filtreleme
5complex_filter = Filter(
6    must=[
7        FieldCondition(key="user_id", match=MatchValue(value="user_123")),
8        FieldCondition(
9            key="created_at",
10            range=DatetimeRange(
11                gte=datetime(2026, 1, 1),
12                lte=datetime(2026, 12, 31)
13            )
14        )
15    ],
16    should=[
17        FieldCondition(key="category", match=MatchValue(value="technical")),
18        FieldCondition(key="category", match=MatchValue(value="tutorial")),
19    ],
20    must_not=[
21        FieldCondition(key="status", match=MatchValue(value="archived"))
22    ]
23)
24 
25# Nested payload filtering (Qdrant 1.8+)
26nested_filter = Filter(
27    must=[
28        FieldCondition(
29            key="metadata.author.company",
30            match=MatchValue(value="Anthropic")
31        )
32    ]
33)

1from langchain_core.output_parsers import StrOutputParser
2from langchain_core.runnables import RunnablePassthrough
3from langchain_openai import ChatOpenAI
4from langchain_qdrant import QdrantVectorStore
5 
6# Qdrant ile LangChain RAG pipeline
7qdrant_store = QdrantVectorStore.from_existing_collection(
8    embedding=OpenAIEmbeddings(model="text-embedding-3-small"),
9    collection_name="documents",
10    url="https://your-cluster.qdrant.io",
11    api_key="your-api-key"
12)
13 
14retriever = qdrant_store.as_retriever(
15    search_type="mmr",  # Maximum Marginal Relevance - çeşitlilik artırır
16    search_kwargs={
17        "k": 10,
18        "fetch_k": 50,  # MMR için 50'den 10 seç
19        "lambda_mult": 0.5,  # 0=çeşitlilik, 1=alaka
20        "filter": {"user_id": "user_123"}  # Metadata filter
21    }
22)
23 
24# RAG chain
25llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
26 
27def format_docs(docs):
28    return "
29 
30---
31 
32".join(
33        f"Kaynak: {doc.metadata.get('source', 'Bilinmiyor')}
34{doc.page_content}"
35        for doc in docs
36    )
37 
38rag_chain = (
39    {"context": retriever | format_docs, "question": RunnablePassthrough()}
40    | ChatPromptTemplate.from_template("""
41        Aşağıdaki context'e dayanarak soruyu Türkçe yanıtla.
42        Yanıtta kullandığın kaynakları belirt.
43 
44        Context:
45        {context}
46 
47        Soru: {question}
48    """)
49    | llm
50    | StrOutputParser()
51)
52 
53answer = rag_chain.invoke("Vector database seçiminde hangi faktörler önemli?")

1# Qdrant snapshot (backup)
2snapshot_info = client.create_snapshot(collection_name="documents")
3print(f"Snapshot oluşturuldu: {snapshot_info.name}")
4 
5# Snapshot restore
6client.recover_from_snapshot(
7    collection_name="documents_restored",
8    location=f"https://your-cluster.qdrant.io/collections/documents/snapshots/{snapshot_info.name}"
9)
10 
11# Pinecone export (built-in yok, manuel)
12def pinecone_export_vectors(index, namespace: str = ""):
13    """Uyarı: Bu işlem büyük index'lerde çok yavaş olabilir"""
14    all_ids = []
15    for ids_batch in index.list(namespace=namespace):
16        all_ids.extend(ids_batch)
17 
18    vectors = {}
19    batch_size = 1000
20    for i in range(0, len(all_ids), batch_size):
21        batch_ids = all_ids[i:i + batch_size]
22        fetch_result = index.fetch(ids=batch_ids, namespace=namespace)
23        vectors.update(fetch_result.vectors)
24 
25    return vectors

1# Weaviate'de yeni property ekleme (non-breaking)
2from weaviate.classes.config import Property, DataType
3 
4collection = client.collections.get("Document")
5 
6# Yeni property ekle - mevcut objeler null value alır
7collection.config.add_property(
8    Property(name="language", data_type=DataType.TEXT)
9)
10 
11# Vektorizasyon stratejisi değiştirme: yeniden indexing gerekir
12# Bunu production'da dikkatli yapın - tüm collection yeniden embed edilir
13collection.config.update(
14    vectorizer_config=Configure.Vectorizer.text2vec_openai(
15        model="text-embedding-3-large",  # Model yükseltme
16        dimensions=3072
17    )
18)