Intégration de la fonction d'incorporation de texte de Milvus avec LangChain

Ce guide explique comment utiliser la fonction d'incorporation de texte de Milvus 2.6 (également connue sous le nom de Data In Data Out) avec LangChain. Cette fonction permet au serveur Milvus de convertir automatiquement du texte brut en incorporations vectorielles, ce qui simplifie le code côté client et centralise la gestion des clés API.

Milvus est la base de données vectorielles open-source la plus avancée au monde, conçue spécifiquement pour prendre en charge les applications de recherche de similarité et d'intelligence artificielle. LangChain est un cadre de développement d'applications alimentées par de grands modèles de langage (LLM). En intégrant la fonction d'incorporation de texte de Milvus, vous pouvez obtenir une solution de recherche vectorielle plus simple et plus efficace dans vos applications LangChain.

Conditions préalables

Avant d'exécuter ce tutoriel, assurez-vous d'avoir installé les dépendances suivantes :

! pip install --upgrade langchain-milvus langchain-core langchain-openai

Configuration du serveur Milvus

Important: la fonction d'incorporation de texte (Data In Data Out) n'est disponible que dans Milvus Server. Milvus Lite ne prend pas en charge cette fonction. Vous devez utiliser un serveur Milvus déployé avec Docker/Kubernetes.

Avant d'utiliser la fonction d'incorporation de texte, vous devez configurer les informations d'identification des fournisseurs de services d'incorporation sur le serveur Milvus.

Déclarez vos clés sous credential :

Vous pouvez répertorier une ou plusieurs clés API - donnez à chacune une étiquette que vous inventez et à laquelle vous ferez référence ultérieurement.

# milvus.yaml

credential:
  apikey_dev:
    apikey: <YOUR_OPENAI_API_KEY>

Indiquer à Milvus la clé à utiliser pour les appels OpenAI

Dans le même fichier, indiquez au fournisseur OpenAI l'étiquette que vous voulez qu'il utilise.

function:
  textEmbedding:
    providers:
      openai:
        credential: apikey_dev
        # url: https://api.openai.com/v1/embeddings   # (optional) custom url

Pour plus de méthodes de configuration, veuillez vous référer à la documentation de la fonction d'intégration Milvus.

Démarrage du service Milvus

Assurez-vous que le serveur Milvus est en cours d'exécution et que la fonction d'intégration est activée. Vous pouvez déployer le serveur Milvus à l'aide de Docker ou de Kubernetes. Remarque : Milvus Lite ne prend pas en charge la fonction d'incorporation de texte.

Comprendre l'incorporation : Côté client vs côté serveur

Avant de plonger dans l'utilisation, commençons par comprendre les différences entre les deux approches d'intégration.

Intégration à l'aide de la classe Embeddings de LangChain (côté client)

Dans l'approche traditionnelle de LangChain, la génération de l'intégration se fait côté client en utilisant la classeEmbeddings . Votre application doit utiliser la méthode embed_query de la classe pour appeler l'API d'intégration, puis stocker les vecteurs générés dans Milvus.

from langchain_openai import OpenAIEmbeddings
from langchain_milvus import Milvus

# Generate embedding on client side
embeddings = OpenAIEmbeddings()
vector = embeddings.embed_query("Hello, world!")
# [0.123, -0.456, ...] A vector of floats

vector_store = Milvus(
    embedding_function=embeddings,
    connection_args={"uri": "http://localhost:19530"},
    collection_name="traditional_approach_collection",
)

Diagramme de séquence :

Caractéristiques :

• Le client appelle directement l'API d'intégration
• Nécessité de gérer les clés API du côté client
• Flux de données : Texte → Client → API d'intégration → Vecteur → Milvus

Fonction d'incorporation de texte de Milvus (données d'entrée et de sortie côté serveur)

La fonction d'incorporation de texte de Milvus 2.6 (Data In Data Out) permet au serveur Milvus de convertir automatiquement du texte brut en incorporations vectorielles. Le client n'a qu'à fournir le texte, et Milvus s'occupe automatiquement de la génération de l'intégration.

Diagramme de séquence :

Caractéristiques :

• Le serveur Milvus appelle l'API d'intégration
• Les clés API sont gérées de manière centralisée du côté du serveur.
• Flux de données : Texte → Milvus → API d'intégration → Vecteur (stocké dans Milvus)

Comparaison des deux méthodes

Fonctionnalité	Intégration LangChain (côté client)	Fonction d'incorporation de texte de Milvus (côté serveur)
Lieu de traitement	Application client	Serveur Milvus
Appels API	Le client appelle directement l'API d'incorporation	Le serveur Milvus appelle l'API d'intégration
Gestion des clés API	Nécessité d'une gestion côté client	Gestion centralisée côté serveur, plus sûre
Complexité du code	Nécessité de gérer les clés et les appels API côté client	Nécessité de configurer une seule fois dans la configuration de Milvus
Cas d'utilisation	- Nécessité d'un contrôle côté client sur le processus d'intégration - Nécessité de mettre en cache les résultats de l'intégration côté client - Nécessité de prendre en charge le changement de modèle d'intégration multiple	- Simplifier le code côté client - Gestion centralisée des clés API côté serveur - Besoin de traiter par lots de grands volumes de documents - Réduction des interactions côté client avec des API externes - Besoin de combiner avec les fonctionnalités intégrées de Milvus comme BM25
Exigences relatives à la version de Milvus	Toutes les versions (y compris Milvus Lite)	Milvus Lite non pris en charge

Ce didacticiel présente principalement la méthode Text Embedding Function (Data In Data Out) côté serveur de Milvus, une nouvelle fonctionnalité introduite dans Milvus 2.6 qui peut simplifier considérablement le code côté client et améliorer la sécurité.

Utilisation de la fonction d'incorporation de texte

Exemple 1 : incorporation côté serveur uniquement

Il s'agit du cas d'utilisation le plus simple, qui repose entièrement sur le serveur Milvus pour générer des incorporations. Le client n'a besoin d'aucune fonction d'intégration.

from langchain_milvus import Milvus
from langchain_milvus.function import TextEmbeddingBuiltInFunction
from langchain_core.documents import Document

# Create Text Embedding Function
text_embedding_func = TextEmbeddingBuiltInFunction(
    input_field_names="text",  # Input field name (field containing text)
    output_field_names="vector",  # Output field name (field storing vectors)
    dim=1536,  # Vector dimension (must specify)
    params={
        "provider": "openai",  # Service provider
        "model_name": "text-embedding-3-small",  # Model name
        "credential": "apikey_dev",    # Optional: use credential label configured in milvus.yaml
    },
)

# Create Milvus vector store
# Note: embedding_function=None, because embedding is done on server side
vector_store = Milvus(
    embedding_function=None,  # Do not use client-side embedding
    builtin_function=text_embedding_func,
    connection_args={"uri": "http://localhost:19530"},
    collection_name="my_collection",
    # consistency_level="Strong",    # Strong consistency level, default is "Session"
    auto_id=True,
    # drop_old=True,  # If you want to drop old collection and create a new one
)

# Add documents (only need to provide text, no need to pre-compute vectors)
documents = [
    Document(page_content="Milvus simplifies semantic search through embeddings."),
    Document(
        page_content="Vector embeddings convert text into searchable numeric data."
    ),
    Document(
        page_content="Semantic search helps users find relevant information quickly."
    ),
]

vector_store.add_documents(documents)

[462726375729313252, 462726375729313253, 462726375729313254]

Lors de la recherche, utilisez directement des requêtes textuelles et Milvus convertira automatiquement le texte de la requête en vecteurs pour la recherche.

# Search (directly use text query)
results = vector_store.similarity_search(
    query="How does Milvus handle semantic search?", k=2
)

for doc in results:
    print(f"Content: {doc.page_content}")
    print(f"Metadata: {doc.metadata}\n")

WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
I0000 00:00:1765186679.227345 12227536 fork_posix.cc:71] Other threads are currently calling into gRPC, skipping fork() handlers


Content: Milvus simplifies semantic search through embeddings.
Metadata: {'pk': 462726375729313252}

Content: Semantic search helps users find relevant information quickly.
Metadata: {'pk': 462726375729313254}

Exemple 2 : Combinaison de l'intégration de texte et de BM25 (recherche hybride)

La combinaison de la recherche sémantique (Text Embedding) et de la recherche par mot-clé (BM25) permet d'obtenir des capacités de recherche hybride plus puissantes. La recherche sémantique permet de mieux comprendre l'intention de la requête, tandis que la recherche par mot-clé permet d'obtenir une correspondance exacte.

from langchain_milvus import Milvus
from langchain_milvus.function import TextEmbeddingBuiltInFunction, BM25BuiltInFunction

# Text Embedding Function (semantic search)
text_embedding_func = TextEmbeddingBuiltInFunction(
    input_field_names="text",
    output_field_names="vector_dense",
    dim=1536,
    params={
        "provider": "openai",
        "model_name": "text-embedding-3-small",
    },
)

# BM25 Function (keyword search)
bm25_func = BM25BuiltInFunction(
    input_field_names="text",
    output_field_names="vector_sparse",
)

# Create Milvus vector store
vector_store = Milvus(
    embedding_function=None,
    builtin_function=[text_embedding_func, bm25_func],
    connection_args={"uri": "http://localhost:19530"},
    vector_field=["vector_dense", "vector_sparse"],
    collection_name="hybrid_search_collection",
    # consistency_level="Strong",    # Strong consistency level, default is "Session"
    auto_id=True,
    # drop_old=True,  # If you want to drop old collection and create a new one
)

# Add documents
documents = [
    Document(page_content="Machine learning and artificial intelligence"),
    Document(page_content="The cat sat on the mat"),
]

vector_store.add_documents(documents)

[462726375729313255, 462726375729313256]

Utilisez WeightedRanker pour contrôler les poids de la recherche sémantique et de la recherche par mot-clé. Lorsque la pondération dense est plus élevée, les résultats sont davantage orientés vers la similarité sémantique ; lorsque la pondération clairsemée est plus élevée, les résultats sont davantage orientés vers la correspondance par mot-clé.

# Hybrid search, use WeightedRanker to control weights
# 70% semantic search, 30% keyword search
results = vector_store.similarity_search(
    query="AI technology",
    k=2,
    ranker_type="weighted",
    ranker_params={"weights": [0.7, 0.3]},
)

# If you want to be more biased towards keyword matching, you can adjust weights
# 30% semantic search, 70% keyword search
results_keyword_focused = vector_store.similarity_search(
    query="cat mat",
    k=2,
    ranker_type="weighted",
    ranker_params={"weights": [0.3, 0.7]},
)

results

[Document(metadata={'pk': 462726375729313255}, page_content='Machine learning and artificial intelligence'),
 Document(metadata={'pk': 462726375729313256}, page_content='The cat sat on the mat')]

results_keyword_focused

[Document(metadata={'pk': 462726375729313256}, page_content='The cat sat on the mat'),
 Document(metadata={'pk': 462726375729313255}, page_content='Machine learning and artificial intelligence')]

Résumé

Nous vous félicitons ! Vous avez appris à utiliser la fonction d'incorporation de texte de Milvus (Data In Data Out) avec LangChain. En déplaçant la génération d'intégration vers le côté serveur, vous pouvez simplifier le code côté client, gérer les clés API de manière centralisée et mettre en œuvre facilement la recherche hybride. Combinée à la fonction d'incorporation de texte et à BM25, Milvus vous offre de puissantes capacités de recherche vectorielle.