Haystack and Zilliz Cloud Integration

Haystack est le framework Python open source de deepset pour créer des applications personnalisées avec de grands modèles de langage (LLM). Il permet aux utilisateurs de construire des pipelines intégrant de grands modèles de langage pour divers scénarios de recherche, notamment la génération augmentée par récupération, les questions-réponses et l’exploration sémantique de documents. Son architecture modulaire permet l’intégration fluide de technologies externes, et les utilisateurs peuvent effectuer des requêtes en langage naturel sans exigences de syntaxe complexe.

En s’intégrant à Zilliz Cloud (Milvus entièrement géré), Haystack accède à une base de données vectorielle entièrement gérée qui offre un stockage et une récupération efficaces de vecteurs de grande dimension, des opérations de recherche rapide par similarité essentielles pour l’exploration sémantique et les pipelines RAG, ainsi que des capacités de mise à l’échelle horizontale pour gérer des déploiements à grande échelle et des volumes de données croissants.

• Stockage et récupération efficaces : Zilliz Cloud gère efficacement les vecteurs de grande dimension, ce qui est particulièrement avantageux lors du traitement de vastes collections de documents et d’embeddings générés par des LLM dans les pipelines Haystack.
• Recherche de similarité rapide : Zilliz Cloud optimise les opérations de recherche de similarité essentielles pour l’exploration sémantique et les pipelines RAG, accélérant considérablement la récupération dans les workflows Haystack.
• Scalabilité : Les capacités de mise à l’échelle horizontale permettent à Haystack de gérer efficacement des déploiements à grande échelle et des volumes de données croissants, avec Zilliz Cloud comme backend de stockage vectoriel.
• Intégration modulaire des pipelines : L’architecture modulaire de Haystack permet l’intégration fluide de Zilliz Cloud comme magasin de documents, améliorant l’efficacité globale du système sans nécessiter de configuration complexe.

Haystack fournit le framework de pipelines pour créer des applications alimentées par des LLM. Il propose des composants modulaires pour la conversion de documents, le découpage de texte, la génération d’embeddings, la récupération, la construction de prompts et la génération de texte — tous connectables dans des pipelines de bout en bout pour l’indexation et l’interrogation.

Zilliz Cloud sert de couche de base de données vectorielle via MilvusDocumentStore, en stockant et en indexant les embeddings de documents pour une recherche de similarité rapide. Il offre une récupération haute performance à faible latence, permettant aux pipelines Haystack de trouver les documents les plus pertinents dans de grandes bases de connaissances.

Ensemble, Haystack et Zilliz Cloud créent une solution RAG complète : le pipeline d’indexation de Haystack traite les documents — en les convertissant, les découpant et générant leurs embeddings — puis les stocke dans Zilliz Cloud via MilvusDocumentStore. Lorsqu’une requête arrive, le pipeline de récupération de Haystack utilise MilvusEmbeddingRetriever pour trouver les documents pertinents grâce à la recherche de similarité vectorielle, puis les transmet au LLM afin de générer des réponses informées par le contexte.

1. Installer les dépendances

Installez les packages requis :

! pip install --upgrade --quiet pymilvus milvus-haystack markdown-it-py mdit_plain

2. Préparer la clé API OpenAI

Préparez la clé API OpenAI comme variable d’environnement :

import os

os.environ["OPENAI_API_KEY"] = "sk-***********"

3. Préparer les données

Téléchargez un contenu en ligne sur Leonardo Da Vinci comme réserve de connaissances privées pour le pipeline RAG :

import urllib.request

url = "https://www.gutenberg.org/cache/epub/7785/pg7785.txt"
file_path = "./davinci.txt"

if not os.path.exists(file_path):
    urllib.request.urlretrieve(url, file_path)

4. Créer le pipeline d’indexation

Créez un pipeline d’indexation qui convertit le texte en documents, les divise en phrases, les vectorise, puis les écrit dans le magasin de documents Milvus :

from haystack import Pipeline
from haystack.components.converters import MarkdownToDocument
from haystack.components.embedders import OpenAIDocumentEmbedder, OpenAITextEmbedder
from haystack.components.preprocessors import DocumentSplitter
from haystack.components.writers import DocumentWriter
from haystack.utils import Secret

from milvus_haystack import MilvusDocumentStore
from milvus_haystack.milvus_embedding_retriever import MilvusEmbeddingRetriever

document_store = MilvusDocumentStore(
    connection_args={"uri": "./milvus.db"},
    # connection_args={"uri": "http://localhost:19530"},
    # connection_args={"uri": YOUR_ZILLIZ_CLOUD_URI, "token": Secret.from_env_var("ZILLIZ_CLOUD_API_KEY")},
    drop_old=False,
)

Pour les connection_args : définir l’uri comme un fichier local, par exemple ./milvus.db, est la méthode la plus pratique, car elle utilise automatiquement Milvus Lite pour stocker toutes les données dans ce fichier. Si vous avez un grand volume de données, vous pouvez configurer un serveur Milvus plus performant sur Docker ou Kubernetes. Si vous souhaitez utiliser Zilliz Cloud, le service cloud entièrement géré pour Milvus, ajustez l’uri et le token, qui correspondent au Public Endpoint et à l’API Key dans Zilliz Cloud.

indexing_pipeline = Pipeline()
indexing_pipeline.add_component("converter", MarkdownToDocument())
indexing_pipeline.add_component(
    "splitter", DocumentSplitter(split_by="sentence", split_length=2)
)
indexing_pipeline.add_component("embedder", OpenAIDocumentEmbedder())
indexing_pipeline.add_component("writer", DocumentWriter(document_store))
indexing_pipeline.connect("converter", "splitter")
indexing_pipeline.connect("splitter", "embedder")
indexing_pipeline.connect("embedder", "writer")
indexing_pipeline.run({"converter": {"sources": [file_path]}})

print("Number of documents:", document_store.count_documents())

5. Créer le pipeline de récupération

Créez un pipeline de récupération qui récupère des documents depuis le magasin de documents Milvus à l’aide d’une recherche de similarité vectorielle :

question = 'Where is the painting "Warrior" currently stored?'

retrieval_pipeline = Pipeline()
retrieval_pipeline.add_component("embedder", OpenAITextEmbedder())
retrieval_pipeline.add_component(
    "retriever", MilvusEmbeddingRetriever(document_store=document_store, top_k=3)
)
retrieval_pipeline.connect("embedder", "retriever")

retrieval_results = retrieval_pipeline.run({"embedder": {"text": question}})

for doc in retrieval_results["retriever"]["documents"]:
    print(doc.content)
    print("-" * 10)

6. Créer le pipeline RAG

Créez un pipeline RAG qui combine le MilvusEmbeddingRetriever et l’OpenAIGenerator pour répondre à la question à l’aide des documents récupérés :

from haystack.components.builders import PromptBuilder
from haystack.components.generators import OpenAIGenerator

prompt_template = """Répondez à la requête suivante en vous basant sur le contexte fourni. Si le contexte
                     ne contient pas de réponse, répondez par 'Je ne sais pas'.\n
                     Requête : {{query}}
                     Documents :
                     {% for doc in documents %}
                        {{ doc.content }}
                     {% endfor %}
                     Réponse :
                  """

rag_pipeline = Pipeline()
rag_pipeline.add_component("text_embedder", OpenAITextEmbedder())
rag_pipeline.add_component(
    "retriever", MilvusEmbeddingRetriever(document_store=document_store, top_k=3)
)
rag_pipeline.add_component("prompt_builder", PromptBuilder(template=prompt_template))
rag_pipeline.add_component(
    "generator",
    OpenAIGenerator(
        api_key=Secret.from_token(os.getenv("OPENAI_API_KEY")),
        generation_kwargs={"temperature": 0},
    ),
)
rag_pipeline.connect("text_embedder.embedding", "retriever.query_embedding")
rag_pipeline.connect("retriever.documents", "prompt_builder.documents")
rag_pipeline.connect("prompt_builder", "generator")

results = rag_pipeline.run(
    {
        "text_embedder": {"text": question},
        "prompt_builder": {"query": question},
    }
)
print("Réponse RAG :", results["generator"]["replies"][0])

• Génération augmentée par récupération (RAG) avec Milvus et Haystack — Tutoriel officiel de Milvus pour créer un RAG avec Haystack
• Créer un pipeline RAG avec Milvus et Haystack 2.0 — Tutoriel de Zilliz sur la création de pipelines RAG efficaces
• milvus-haystack sur PyPI — Le package officiel d’intégration de Milvus pour Haystack
• Dépôt GitHub milvus-haystack — Code source de l’intégration Milvus-Haystack
• Documentation Haystack — Documentation officielle de Haystack par deepset