LangChain and Zilliz Cloud Integration

LangChain est un framework open-source pour créer des agents et des applications propulsés par des LLM. Il fournit une architecture d’agent préconstruite et des intégrations pour les modèles et les outils, ce qui facilite la connexion à des fournisseurs tels qu’OpenAI, Anthropic et Google, ainsi que le démarrage rapide de la création. LangChain est conçu pour être facile à utiliser tout en restant suffisamment flexible pour les workflows personnalisés, et ses agents sont construits sur LangGraph pour des capacités telles que l’exécution durable, le streaming, la persistance et la prise en charge de l’humain dans la boucle.

En intégrant Zilliz Cloud (Milvus entièrement géré) à LangChain, vous pouvez ajouter la recherche et la récupération vectorielles haute performance à vos applications LLM, ce qui facilite la création de pipelines RAG, d’agents et de workflows d’IA contextuels à partir de vos propres données.

• Facilite la création d’applications LLM qui utilisent des connaissances externes, des outils et la récupération, sans avoir à assembler manuellement chaque composant.
• Utilise LangChain pour orchestrer les prompts, les chaînes et les flux de récupération au sein de l’application.
• Utilise Zilliz Cloud (Milvus géré) comme couche de base de données vectorielle pour stocker les embeddings et effectuer une recherche sémantique sur vos données.
• Fonctionne particulièrement bien pour les charges de travail RAG et de questions-réponses sur documents, où les informations pertinentes doivent être récupérées dynamiquement afin d’améliorer la qualité des réponses.
• Permet aux développeurs de se concentrer davantage sur la logique applicative et moins sur la gestion de l’infrastructure vectorielle et des systèmes de récupération.

LangChain sert de framework pour développer des applications alimentées par des modèles de langage. Il aide à connecter les modèles de langage à des sources contextuelles telles que des instructions de prompt, des exemples few-shot, des outils externes et du contenu pertinent stocké dans des bases de données vectorielles. Cela rend les applications plus sensibles au contexte et mieux capables de générer des réponses ancrées dans les bonnes informations. LangChain permet également des workflows guidés par le raisonnement, permettant aux applications de décider comment répondre en fonction du contexte disponible et des actions à entreprendre ensuite. Grâce à ses composants modulaires et à ses chaînes prêtes à l’emploi, les développeurs peuvent soit assembler rapidement des workflows LLM courants, soit les personnaliser pour des applications plus complexes.

Zilliz Cloud, la version entièrement managée de Milvus, fournit la couche de base de données vectorielle pour stocker, indexer et récupérer des embeddings à grande échelle. Lorsque les données d’application sont converties en vecteurs, Zilliz Cloud permet d’exécuter une recherche de similarité rapide et de renvoyer le contenu le plus pertinent pour une requête donnée. Cela offre aux applications LangChain un moyen fiable de récupérer des connaissances externes et de les utiliser comme contexte pendant la génération.

Ensemble, LangChain et Zilliz Cloud facilitent la création d’applications LLM sensibles au contexte et de workflows de génération augmentée par récupération. LangChain gère la logique applicative, les chaînes et le flux de raisonnement, tandis que Zilliz Cloud fournit une récupération haute performance sur vos données. Cette combinaison aide les développeurs à créer des applications d’IA capables d’accéder à des connaissances pertinentes, de répondre avec un meilleur ancrage et de monter en charge plus efficacement en production.

1. Installer les packages requis

Commencez par installer l’intégration LangChain Milvus, Milvus Lite et le package d’intégration OpenAI. La documentation Milvus utilise cette configuration pour le développement local et le prototypage. (Milvus)

pip install -qU langchain-milvus milvus-lite langchain-openai

Milvus Lite est inclus avec la dernière version de pymilvus et stocke tout dans un fichier local, ce qui en fait une option simple pour commencer. Pour les charges de travail à plus grande échelle, la documentation recommande plutôt d’exécuter un serveur Milvus complet. (Milvus)

2.Initialiser les embeddings et se connecter à Milvus

Ensuite, créez votre modèle d’embedding et initialisez le magasin de vecteurs Milvus. Dans l’exemple officiel, les embeddings sont générés avec OpenAIEmbeddings(model="text-embedding-3-large"), et le magasin de vecteurs pointe vers un fichier .db local via Milvus Lite. La même interface peut également se connecter à un serveur Milvus en cours d’exécution en remplaçant l’URI local par une adresse de serveur telle que http://localhost:19530. (Milvus)

from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-large")

from langchain_milvus import Milvus

# The easiest way is to use Milvus Lite where everything is stored in a local file.
# If you have a Milvus server you can use the server URI such as "http://localhost:19530".
URI = "./milvus_example.db"

vector_store = Milvus(
    embedding_function=embeddings,
    connection_args={"uri": URI},
)

3.Organiser les données avec des collections

Milvus permet de stocker des jeux de données sans rapport entre eux dans différentes collections au sein de la même instance Milvus. Cela aide à garder les contextes séparés et rend le magasin de vecteurs plus facile à gérer. La documentation montre d’abord comment créer une collection à partir de documents, puis comment recharger cette même collection par son nom. (Milvus)

from langchain_core.documents import Document

vector_store_saved = Milvus.from_documents(
    [Document(page_content="foo!")],
    embeddings,
    collection_name="langchain_example",
    connection_args={"uri": URI},
)

vector_store_loaded = Milvus(
    embeddings,
    connection_args={"uri": URI},
    collection_name="langchain_example",
)

4.Ajouter des documents au magasin de vecteurs

Une fois le magasin de vecteurs prêt, vous pouvez insérer des documents avec add_documents. Le tutoriel officiel utilise dix exemples de documents et attribue à chacun un UUID avant de les insérer. Les métadonnées telles que "source": "tweet" ou "source": "news" sont stockées avec chaque document et peuvent ensuite être utilisées pour filtrer lors de la recherche. (Milvus)

from uuid import uuid4

from langchain_core.documents import Document

document_1 = Document(
    page_content="I had chocalate chip pancakes and scrambled eggs for breakfast this morning.",
    metadata={"source": "tweet"},
)
document_2 = Document(
    page_content="The weather forecast for tomorrow is cloudy and overcast, with a high of 62 degrees.",
    metadata={"source": "news"},
)

document_3 = Document(
    page_content="Building an exciting new project with LangChain - come check it out!",
    metadata={"source": "tweet"},
)

document_4 = Document(
    page_content="Robbers broke into the city bank and stole $1 million in cash.",
    metadata={"source": "news"},
)
document_5 = Document(
    page_content="Wow! That was an amazing movie. I can't wait to see it again.",
    metadata={"source": "tweet"},
)

document_6 = Document(
    page_content="Is the new iPhone worth the price? Read this review to find out.",
    metadata={"source": "website"},
)

document_7 = Document(
    page_content="The top 10 soccer players in the world right now.",
    metadata={"source": "website"},
)
document_8 = Document(
    page_content="LangGraph is the best framework for building stateful, agentic applications!",
    metadata={"source": "tweet"},
)

document_9 = Document(
    page_content="The stock market is down 500 points today due to fears of a recession.",
    metadata={"source": "news"},
)

document_10 = Document(
    page_content="I have a bad feeling I am going to get deleted :(",
    metadata={"source": "tweet"},
)

documents = [
    document_1,
    document_2,
    document_3,
    document_4,
    document_5,
    document_6,
    document_7,
    document_8,
    document_9,
    document_10,
]

uuids = [str(uuid4()) for _ in range(len(documents))]

vector_store.add_documents(documents=documents, ids=uuids)

5.Supprimer les documents lorsque nécessaire

Le tutoriel montre également comment supprimer des documents par ID. C’est utile lorsque des enregistrements deviennent obsolètes ou doivent être mis à jour via un flux de travail de suppression puis réinsertion. Dans l’exemple ci-dessous, le dernier document inséré est supprimé à l’aide de son UUID. (Milvus)

vector_store.delete(ids=[uuids[-1]])

6. Exécuter une recherche par similarité

Une fois les documents stockés, vous pouvez interroger directement le vector store. L’exemple de base utilise similarity_search() avec k=2 et une expression de filtre de métadonnées, expr='source == "tweet"', pour rechercher uniquement parmi des documents de type tweet. Cela montre que LangChain + Milvus prend en charge à la fois la similarité vectorielle et le filtrage structuré dans la même requête. (Milvus)

results = vector_store.similarity_search(
    "LangChain provides abstractions to make working with LLMs easy",
    k=2,
    expr='source == "tweet"',
    # param=...  # Search params for the index type
)

for res in results:
    print(f"* {res.page_content} [{res.metadata}]")

Exemple de sortie tiré de la documentation :

* Building an exciting new project with LangChain - come check it out! [{'source': 'tweet', 'pk': 'e991a253-5f37-46ae-850a-82a660e33013'}]
* LangGraph is the best framework for building stateful, agentic applications! [{'source': 'tweet', 'pk': 'eb149e29-239a-4e2c-9f99-751cb7207abf'}]

7. Rechercher avec des scores de similarité

Si vous voulez également le score de similarité, utilisez similarity_search_with_score(). L’exemple officiel interroge du contenu lié à la météo et filtre les documents "news". C’est utile lorsque vous souhaitez inspecter la qualité du classement ou décider comment définir un seuil pour les résultats de récupération avant de les transmettre à un LLM. (Milvus)

results = vector_store.similarity_search_with_score(
    "Will it be hot tomorrow?", k=1, expr='source == "news"'
)

for res, score in results:
    print(f"* [SIM={score:3f}] {res.page_content} [{res.metadata}]")

Exemple de sortie tiré de la documentation :

* [SIM=0.893776] The weather forecast for tomorrow is cloudy and overcast, with a high of 62 degrees. [{'source': 'news', 'pk': 'dbf6560a-1487-4a6e-8797-245d57874f5b'}]

8. Transformer le vector store en retriever

Pour la plupart des applications LangChain, en particulier les pipelines RAG, il est souvent plus pratique de convertir le vector store en retriever. La documentation le montre avec as_retriever(search_type="mmr", search_kwargs={"k": 1}). Une fois converti, vous pouvez appeler invoke() et toujours appliquer des filtres de métadonnées via expr. (Milvus)

retriever = vector_store.as_retriever(search_type="mmr", search_kwargs={"k": 1})
retriever.invoke("Stealing from the bank is a crime", expr='source == "news"')

Exemple de sortie tiré de la documentation :

[Document(metadata={'source': 'news', 'pk': '2818c051-5a1a-44cb-9deb-aaaac709f616'}, page_content='Robbers broke into the city bank and stole $1 million in cash.')]

C’est à ce stade que l’intégration devient particulièrement utile pour les chaînes et agents en aval, car les retrievers s’intègrent naturellement dans des flux de travail LangChain plus vastes. (Milvus)

9. Utiliser des clés de partition pour la récupération par utilisateur

Si votre application sert plusieurs utilisateurs, la documentation Milvus recommande d’utiliser partition_key pour la multilocation afin que les utilisateurs ne récupèrent que leurs propres données. L’exemple utilise un champ namespace comme clé de partition, puis filtre la récupération avec des expressions comme namespace == "ankush". La documentation indique également que la clé de partition n’est pas disponible dans Milvus Lite, cette partie nécessite donc un serveur Milvus exécuté via Docker ou Kubernetes. (Milvus)

from langchain_core.documents import Document

docs = [
    Document(page_content="i worked at kensho", metadata={"namespace": "harrison"}),
    Document(page_content="i worked at facebook", metadata={"namespace": "ankush"}),
]

vectorstore = Milvus.from_documents(
    docs,
    embeddings,
    collection_name="partitioned_collection",  # Utiliser un nom de collection différent
    connection_args={"uri": URI},
    # drop_old=True,
    partition_key_field="namespace",  # Utiliser le champ "namespace" comme clé de partition
)

Pour effectuer une recherche avec la clé de partition, incluez-la dans l’expression booléenne :

search_kwargs={"expr": '<partition_key> == "xxxx"'}

ou

search_kwargs={"expr": '<partition_key> == in ["xxx", "xxx"]'}

Remplacez <partition_key> par le nom réel du champ que vous avez désigné comme clé de partition. Milvus filtre ensuite les entités par clé de partition avant la recherche. (Milvus)

Exemples de récupérations issus de la documentation :

# This will only get documents for Ankush
vectorstore.as_retriever(search_kwargs={"expr": 'namespace == "ankush"'}).invoke(
    "where did i work?"
)

[Document(metadata={'namespace': 'ankush', 'pk': 460829372217788296}, page_content='i worked at facebook')]

# This will only get documents for Harrison
vectorstore.as_retriever(search_kwargs={"expr": 'namespace == "harrison"'}).invoke(
    "where did i work?"
)

[Document(metadata={'namespace': 'harrison', 'pk': 460829372217788295}, page_content='i worked at kensho')]

• Tutoriel | Débuter avec LangChain et Milvus
• Tutoriel | Guide ultime pour débuter avec LangChain
• Tutoriel | Utiliser LangChain pour interroger automatiquement une base de données vectorielle
• Vidéo avec Harrison Chase | Mémoire pour les applications LLM : différentes techniques de récupération pour obtenir le contexte le plus pertinent
• Vidéo courte avec Yujian Tang | Comment ajouter une mémoire conversationnelle à un LLM avec LangChain
• Vidéo avec Lance Martin | Déboguer vos applications RAG avec LangSmith