Weaviate führt die hybride Suche 2.0 mit 60 % schnelleren Abfragezeiten ein

Ankündigung

Weaviate hat Hybrid Search 2.0 veröffentlicht, eine vollständige Neuschreibung ihrer hybriden Suchmaschine, die deutlich bessere Performance und Genauigkeit bietet und gleichzeitig die Konfiguration vereinfacht.

Wichtige Verbesserungen

Leistungsgewinne

Verglichen mit Hybrid Search 1.0 :

Einheitlicher Index

v2.0 utilise un seul index unifié pour la recherche vectorielle et par mots-clés :

Ancien (v1.0) :

Index vectoriel (HNSW) + Index mots-clés (BM25) = 2 index
→ Rechercher les deux, fusionner les résultats

Nouveau (v2.0) :

Index hybride unifié = 1 index
→ Traversée unique, scoring fusionné

Vorteile :

• 40% weniger Speicherbedarf
• Schnellere Abfragen (kein Overhead durch das Zusammenführen)
• Bessere Cache-Lokalität

Gelernte Fusion

Ersetzt die manuelle Abstimmung von alpha durch eine gelernte Fusion :

Ancienne approche :

DEVELOPERpython
# Manual tuning required
results = client.query.get("Document")
  .with_hybrid(query, alpha=0.7)  # Trial and error
  .do()

Nouvelle approche :

DEVELOPERpython
# Automatic learned fusion
results = client.query.get("Document")
  .with_hybrid(query, fusion_type="learned")  # No alpha needed
  .do()

Das Modell der gelernten Fusion trainiert auf Anfrage-Mustern, um das Scoring zu optimieren.

Benchmark :

• Alpha manuel : 52.3% nDCG@10
• Fusion apprise : 57.8% nDCG@10 (+10.5%)

Nouvelles fonctionnalités

Filterbewusste hybride Suche

La recherche hybride respecte maintenant les filtres efficacement :

DEVELOPERpython
results = (
    client.query.get("Product")
    .with_hybrid("wireless headphones", fusion_type="learned")
    .with_where({
        "path": ["price"],
        "operator": "LessThan",
        "valueNumber": 200
    })
    .with_limit(10)
    .do()
)

Performance :

• v1.0 : Post-filtrage (lent)
• v2.0 : Traversée d'index consciente des filtres (60% plus rapide)

Hybride multi-vecteurs

Support pour plusieurs représentations vectorielles :

DEVELOPERpython
# Index with multiple embeddings
client.data_object.create({
    "text": "Product description...",
    "vectors": {
        "semantic": [...],  # General embedding
        "domain": [...],    # Domain-specific embedding
        "multilingual": [...] # Cross-lingual embedding
    }
})

# Query with automatic vector selection
results = client.query.get("Product")
  .with_hybrid(query, vector_name="auto")  # Selects best vector
  .do()

Explication hybride

Déboguer le scoring de recherche hybride :

DEVELOPERpython
results = (
    client.query.get("Document")
    .with_hybrid(query, explain=True)
    .do()
)

for result in results:
    print(f"Combined score: {result['_additional']['score']}")
    print(f"  BM25 score: {result['_additional']['explainScore']['bm25']}")
    print(f"  Vector score: {result['_additional']['explainScore']['vector']}")
    print(f"  Fusion weight: {result['_additional']['explainScore']['fusion']}")

Hilft zu verstehen, warum Dokumente so gerankt wurden.

Architekturänderungen

HNSW-BM25 Fusionsindex

Neue Indexstruktur :

Nœuds du graphe HNSW :
  - Embedding vectoriel
  - Fréquences de termes BM25
  - Métadonnées
  - Filtres

Traversée unique :
  - Naviguer dans le graphe HNSW
  - Calculer la similarité vectorielle
  - Calculer le score BM25
  - Appliquer la fusion apprise
  - Vérifier les filtres (terminaison anticipée)

Kerninnovation : BM25-Daten kolokalisiert mit den HNSW-Knoten.

Dynamische Fusion

Les poids de fusion s'adaptent par requête :

DEVELOPERpython
# Query analysis
query_type = analyze(query)  # keyword-heavy vs. semantic

if query_type == "keyword-heavy":
    fusion_weights = {"bm25": 0.7, "vector": 0.3}
elif query_type == "semantic":
    fusion_weights = {"bm25": 0.3, "vector": 0.7}
else:
    fusion_weights = {"bm25": 0.5, "vector": 0.5}

# Apply dynamically
score = (
    fusion_weights["bm25"] * bm25_score +
    fusion_weights["vector"] * vector_score
)

Eliminiert die Notwendigkeit der manuellen Anpassung von alpha.

Migrationsleitfaden

Upgrade von v1.0

DEVELOPERpython
# Old (v1.0)
results = (
    client.query.get("Document")
    .with_hybrid(query="search query", alpha=0.75)
    .with_limit(10)
    .do()
)

# New (v2.0) - minimal changes
results = (
    client.query.get("Document")
    .with_hybrid(
        query="search query",
        fusion_type="learned"  # Replace alpha
    )
    .with_limit(10)
    .do()
)

Reindexierung

v2.0 nécessite une réindexation :

DEVELOPERbash
# Export data
weaviate export --collection Documents --output backup.json

# Upgrade Weaviate
docker pull semitechnologies/weaviate:1.25.0

# Reimport (automatically uses new index)
weaviate import --collection Documents --input backup.json

Ausfallzeit : ~2 heures pour 10M de documents

Benchmarks

BEIR-Benchmark

Getestet sur le benchmark de récupération BEIR :

Durchschnittliche Verbesserung : +6.8% gegenüber v1.0

Reale Performance

Kundenbericht (10M Dokumente) :

Latenz :

• p50 : 34ms (war 85ms)
• p95 : 78ms (war 240ms)
• p99 : 145ms (war 580ms)

Durchsatz :

• Einzelner Knoten : 3,500 q/s (war 1,200 q/s)
• Cluster 3 Knoten : 9,800 q/s (war 3,100 q/s)

Kosten :

• Dieselbe Infrastruktur bewältigt 3x den Traffic
• Kostenreduktion pro Anfrage um 66%

Best Practices

Auswahl des Fusionstyps

DEVELOPERpython
# Use learned fusion (default)
.with_hybrid(query, fusion_type="learned")

# Use relative score (for specific use cases)
.with_hybrid(query, fusion_type="relative_score", alpha=0.7)

# Use RRF (rank-based fusion)
.with_hybrid(query, fusion_type="rrf")

Empfehlung : Mit der gelernten Fusion beginnen.

Filteroptimierung

DEVELOPERpython
# Good: Selective filters first
.with_where({
    "operator": "And",
    "operands": [
        {"path": ["category"], "operator": "Equal", "valueString": "electronics"},
        {"path": ["price"], "operator": "LessThan", "valueNumber": 200}
    ]
})

# Bad: Non-selective filters first (slower)

Auswahl der vector-Repräsentation

DEVELOPERpython
# Let Weaviate choose
.with_hybrid(query, vector_name="auto")

# Or specify explicitly
.with_hybrid(query, vector_name="semantic")

Verfügbarkeit

• Weaviate 1.25+ (veröffentlicht im Oktober 2025)
• Weaviate Cloud Services (WCS) - wird automatisch aktualisiert
• Self-hosted - Upgrade verfügbar

Einschränkungen

Reindexierung erforderlich

• Kein In-place-Upgrade möglich
• Indexe müssen neu aufgebaut werden
• Ausfallzeit einplanen

Speicherverbrauch

• Der einheitliche Index benötigt 15% mehr RAM (aber weniger Festplattenspeicher)
• Die Vorteile überwiegen die Kosten für die meisten Anwendungsfälle

Lernphase

• Die gelernte Fusion benötigt ~1000 Anfragen, um sich zu optimieren
• Fällt bis zum Training auf Heuristiken zurück

Fahrplan

Geplant pour 2026 :

• Recherche hybride multi-modale (texte + images)
• BM25 sémantique (pondération contextuelle des termes)
• Recherche hybride augmentée par graphe
• Mises à jour du modèle de fusion en temps réel

Ressourcen

• Documentation : weaviate.io/developers/hybrid-search-v2
• Guide de migration : weaviate.io/developers/migration/v2
• Benchmarks : weaviate.io/benchmarks/hybrid-search

Fazit

Hybrid Search 2.0 von Weaviate stellt einen bedeutenden Fortschritt in der Retrieval-Technologie dar und kombiniert Performance-Verbesserungen mit besserer Genauigkeit durch gelernte Fusion. Die Architektur des einheitlichen Indexes setzt einen neuen Standard für hybride Suche in Vektor-Datenbanken und macht es zu einer ausgezeichneten Wahl für RAG-Anwendungen in Produktion.