Integration der Milvus-Text-Einbettungsfunktion mit LangChain

Dieser Leitfaden zeigt, wie die Texteinbettungsfunktion von Milvus 2.6 (auch bekannt als Data In Data Out) mit LangChain verwendet werden kann. Diese Funktion ermöglicht es dem Milvus-Server, Rohtext automatisch in Vektoreinbettungen zu konvertieren, was den clientseitigen Code vereinfacht und die Verwaltung der API-Schlüssel zentralisiert.

Milvus ist die weltweit fortschrittlichste Open-Source-Vektordatenbank, die speziell zur Unterstützung von Einbettungsähnlichkeitssuche und KI-Anwendungen entwickelt wurde. LangChain ist ein Framework für die Entwicklung von Anwendungen, die auf großen Sprachmodellen (LLMs) basieren. Durch die Integration der Texteinbettungsfunktion von Milvus können Sie eine einfachere und effizientere Vektorsuchlösung in Ihren LangChain-Anwendungen erreichen.

Voraussetzungen

Bevor Sie dieses Tutorial ausführen, stellen Sie sicher, dass Sie die folgenden Abhängigkeiten installiert haben:

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

Konfigurieren des Milvus-Servers

Wichtig: Die Funktion der Texteinbettung (Data In Data Out) ist nur in Milvus Server verfügbar. Milvus Lite unterstützt diese Funktion nicht. Sie müssen einen Milvus-Server verwenden, der mit Docker/Kubernetes bereitgestellt wird.

Bevor Sie die Texteinbettungsfunktion verwenden können, müssen Sie die Anmeldeinformationen für die Einbettungsdienstanbieter auf dem Milvus-Server konfigurieren.

Deklarieren Sie Ihre Schlüssel unter credential:

Sie können einen oder mehrere API-Schlüssel auflisten - geben Sie jedem einen Namen, den Sie selbst erfinden und später referenzieren werden.

# milvus.yaml

credential:
  apikey_dev:
    apikey: <YOUR_OPENAI_API_KEY>

Teilen Sie Milvus mit, welchen Schlüssel es für OpenAI-Aufrufe verwenden soll

In derselben Datei weisen Sie dem OpenAI-Anbieter das Label zu, das er verwenden soll.

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

Weitere Konfigurationsmethoden finden Sie in der Dokumentation der Milvus Embedding Function.

Starten des Milvus-Dienstes

Stellen Sie sicher, dass Milvus Server läuft und die Einbettungsfunktion aktiviert ist. Sie können Milvus Server mit Docker oder Kubernetes bereitstellen. Hinweis: Milvus Lite unterstützt die Texteinbettungsfunktion nicht.

Verstehen der Einbettung: Client-seitig vs. Server-seitig

Bevor wir in die Nutzung eintauchen, sollten wir zunächst die Unterschiede zwischen den beiden Einbettungsansätzen verstehen.

Einbettung mit der Embeddings Klasse von LangChain (Client-seitig)

Beim traditionellen LangChain-Ansatz erfolgt die Erzeugung der Einbettung auf der Client-Seite unter Verwendung der KlasseEmbeddings . Ihre Anwendung muss die embed_query -Methode der Klasse verwenden, um die Einbettungs-API aufzurufen, und dann die erzeugten Vektoren in Milvus speichern.

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",
)

Sequenzdiagramm:

Merkmale:

• Client ruft Einbettungs-API direkt auf
• API-Schlüssel müssen auf der Client-Seite verwaltet werden
• Datenfluss: Text → Client → Einbettungs-API → Vektor → Milvus

Milvus-Text-Einbettungsfunktion (Server-seitiger Dateneingang Datenausgang)

Mit der Texteinbettungsfunktion von Milvus 2.6 (Data In Data Out) kann der Milvus-Server automatisch Rohtext in Vektoreinbettungen umwandeln. Der Client muss nur den Text bereitstellen und Milvus übernimmt automatisch die Erzeugung der Einbettungen.

Sequenzdiagramm:

Merkmale:

• Milvus-Server ruft Einbettungs-API auf
• API-Schlüssel werden zentral auf der Serverseite verwaltet
• Datenfluss: Text → Milvus → Einbettungs-API → Vektor (in Milvus gespeichert)

Vergleich der beiden Methoden

Merkmal	LangChain-Einbettung (Client-seitig)	Milvus-Text-Einbettungsfunktion (Server-seitig)
Ort der Verarbeitung	Client-Anwendung	Milvus-Server
API-Aufrufe	Client ruft Einbettungs-API direkt auf	Milvus-Server ruft Einbettungs-API auf
API-Schlüssel-Verwaltung	Muss auf Client-Seite verwaltet werden	Zentrale Verwaltung auf der Serverseite, mehr Sicherheit
Code-Komplexität	API-Schlüssel und -Aufrufe müssen auf der Client-Seite verwaltet werden	Muss nur einmal in der Milvus-Konfiguration konfiguriert werden
Anwendungsfälle	- Client-seitige Kontrolle über den Einbettungsprozess erforderlich - Notwendigkeit der Zwischenspeicherung von Einbettungsergebnissen auf der Client-Seite - Unterstützung für den Wechsel zwischen mehreren Einbettungsmodellen	- Vereinfachung des clientseitigen Codes - Zentrale Verwaltung von API-Schlüsseln auf der Serverseite - Notwendigkeit der Stapelverarbeitung großer Mengen von Dokumenten - Client-seitige Interaktionen mit externen APIs reduzieren wollen - mit den in Milvus integrierten Funktionen wie BM25 kombiniert werden müssen
Anforderungen an die Milvus-Version	Alle Versionen (einschließlich Milvus Lite)	Milvus Lite wird nicht unterstützt

Dieses Tutorial stellt in erster Linie die serverseitige Milvus-Methode "Text Embedding Function" (Data In Data Out) vor. Dabei handelt es sich um eine neue Funktion, die in Milvus 2.6 eingeführt wurde und den clientseitigen Code erheblich vereinfachen und die Sicherheit verbessern kann.

Verwendung der Texteinbettungsfunktion

Beispiel 1: Nur Server-seitige Einbettung

Dies ist der einfachste Anwendungsfall, bei dem die Einbettungen vollständig vom Milvus-Server erzeugt werden. Der Client benötigt keine Einbettungsfunktion.

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]

Bei der Suche können Sie direkt Textabfragen verwenden, und Milvus wandelt den Abfragetext automatisch in Vektoren für die Suche um.

# 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}

Beispiel 2: Kombination von Texteinbettung und BM25 (Hybride Suche)

Die Kombination von semantischer Suche (Texteinbettung) und Schlagwortsuche (BM25) ermöglicht leistungsfähigere hybride Suchfunktionen. Die semantische Suche zeichnet sich dadurch aus, dass sie die Absicht der Anfrage versteht, während die Schlagwortsuche sich durch exakte Übereinstimmung auszeichnet.

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]

Verwenden Sie WeightedRanker, um die Gewichtung der semantischen Suche und der Schlüsselwortsuche zu steuern. Bei einer höheren Gewichtung der dichten Suche werden die Ergebnisse stärker auf die semantische Ähnlichkeit ausgerichtet; bei einer höheren Gewichtung der spärlichen Suche werden die Ergebnisse stärker auf die Stichwortsuche ausgerichtet.

# 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')]

Zusammenfassung

Herzlichen Glückwunsch! Sie haben gelernt, wie Sie die Text-Einbettungsfunktion (Data In Data Out) von Milvus mit LangChain nutzen können. Indem Sie die Erzeugung von Einbettungen auf die Serverseite verlagern, können Sie den clientseitigen Code vereinfachen, API-Schlüssel zentral verwalten und eine hybride Suche leicht implementieren. In Kombination mit der Texteinbettungsfunktion und BM25 bietet Ihnen Milvus leistungsstarke Vektorsuchfunktionen.