Wie LangChain Self Querying implementiert
LangChain ist eine äußerst beliebte Open-Source-Bibliothek für die LLM-Orchestrierung. Kürzlich haben sie den „Self Query“-Retriever hinzugefügt. Der „Self Query“-Retriever ermöglicht es dir, LangChain zu verwenden, um eine Vektordatenbank abzufragen, wie etwa Milvus. Werfen wir einen Blick darauf, wie dieser Self-Query-Retriever implementiert ist. Wir behandeln die Zeilen 189 bis 233 der Datei base.py im Self-Query-Ordner. Dieser Beitrag behandelt außerdem from_llm, die einzige Klassenmethode.
In diesem Beitrag behandeln wir:
- Die Definition der Self-Query-Klassenmethode
- Das Parsen der Self-Query-Parameter
- Das Erstellen der LLM-Chain
- Das Zurückgeben eines Self-Query-Retrievers
Definition der Self-Query-Klassenmethode
Die einzige Klassenmethode für die Self-Query-Basisklasse ist from_llm. Es gibt acht angegebene Parameter und einen, der es uns erlaubt, Keyword-Argumente (kwargs) zu übergeben. Vielleicht fällt dir auf, dass der erste „Parameter“ der Klasse cls ist. Wenn du keine formale Ausbildung in Python hast, ist der Unterschied zwischen cls und self laut PEP8 einfach eine Frage von Stil und Verwendung.
Es gibt vier erforderliche Parameter zum Erstellen einer Self-Query-Klasse: llm, vectorstore, document_contents und metadata_field_info.
llmdient zum Übergeben eines Sprachmodells.vectorstorewird verwendet, um einen Vektorspeicher wie Milvus zu übergeben.- Der Name des Parameters
document_contentsist etwas irreführend. Er bezieht sich nicht auf die tatsächlichen Inhalte der gespeicherten Dokumente, sondern vielmehr auf eine kurze Beschreibung davon. metadata_field_infoist eine Sequenz vonAttributeInfo-Objekten, also Dictionaries, die Informationen über die Daten in der Vektordatenbank enthalten.
Nach den erforderlichen Parametern kommen die optionalen Parameter. Davon gibt es ebenfalls vier: structured_query_translator, chain_kwargs, enable_limit und use_original_query. Die ersten beiden sind standardmäßig None, und die zweiten False.
Der Parameter structured_query_translator ermöglicht es uns, einen Translator zu übergeben. Translators wandeln Ausdrücke in Filteranweisungen für jede Vektordatenbank um. Diese Filteranweisungen werden je nach Verwendung als „allowed_comparators“ oder „allowed_operators“ an chain_kwargs übergeben. Jeder Vektorspeicher hat einzigartige Comparators und Operators. Zum Beispiel sind dies die zulässigen booleschen Ausdrücke für Milvus.
Mit dem Parameter enable_limit können wir entscheiden, ob der Limit-Operator aktiviert werden soll. Dieser Operator ist eine native Funktion von LangChain, die die Anzahl der abzurufenden Dokumente beschränkt. Der letzte Parameter ist use_original_query, der bestimmt, ob wir unsere ursprüngliche Abfrage oder die von LLM generierte verwenden möchten.
@classmethod
def from_llm(
cls,
llm: BaseLanguageModel,
vectorstore: VectorStore,
document_contents: str,
metadata_field_info: Sequence[Union[AttributeInfo, dict]],
structured_query_translator: Optional[Visitor] = None,
chain_kwargs: Optional[Dict] = None,
enable_limit: bool = False,
use_original_query: bool = False,
**kwargs: Any,
) -> "SelfQueryRetriever":
Parsen der Self-Query-Parameter
Lass mich erklären, wie wir mit den Parametern umgehen. Basierend auf den übergebenen Parametern verwenden wir eine Reihe von if-Anweisungen, um zu bestimmen, was zu tun ist.
Zuerst prüfen wir, ob bereits ein strukturierter Query-Translator definiert ist. Falls nicht, verwenden wir den eingebauten Translator für den definierten Vektorspeicher.
Als Nächstes prüfen wir die Chain-Schlüsselwortargumente. Wir können sie auf die übergebenen Werte setzen oder in einem leeren Dictionary belassen. Wir prüfen diese Argumente weiterhin für die folgenden zwei if-Anweisungen. Die zwei Schlüssel, nach denen wir suchen, sind die erlaubten Komparatoren und Operatoren. Diese Schlüssel bestimmen, wie wir die Filterausdrücke schreiben können.
if structured_query_translator is None:
structured_query_translator = _get_builtin_translator(vectorstore)
chain_kwargs = chain_kwargs or {}
if (
"allowed_comparators" not in chain_kwargs
and structured_query_translator.allowed_comparators is not None
):
chain_kwargs[
"allowed_comparators"
] = structured_query_translator.allowed_comparators
if (
"allowed_operators" not in chain_kwargs
and structured_query_translator.allowed_operators is not None
):
chain_kwargs[
"allowed_operators"
] = structured_query_translator.allowed_operators
Erstellen der LLM-Chain
Nachdem alles definiert ist, können wir nun unseren Query Constructor erstellen. In diesem Schritt verweisen wir auf die Funktion load_query_constructor_runnable aus den Query Constructors. Wir werden in einem anderen Artikel tiefer in diesen Schritt eintauchen.
Wir müssen das LLM, die Beschreibung des Dokumentinhalts, die Metadatenfelder, ob wir das Limit aktivieren möchten oder nicht, und die Schlüsselwortargumente übergeben, die an die Chain weitergegeben werden sollen. Nachdem wir all diese Elemente definiert haben, gibt die Funktion ein Runnable-Objekt zurück, mit dem wir ein angegebenes Skript ausführen können.
query_constructor = load_query_constructor_runnable(
llm,
document_contents,
metadata_field_info,
enable_limit=enable_limit,
**chain_kwargs,
)
Zurückgeben eines Self Query Retriever
Am Ende dieser Klassenmethode müssen wir den Self Query Retriever zurückgeben. Diese Methode gibt eine Instanz der Self-Query-Klasse zurück. Wir übergeben den Query Constructor, den wir gerade definiert haben, zusammen mit dem übergebenen Vector Store, der Angabe, ob die ursprüngliche Abfrage verwendet werden soll oder nicht, dem Translator und einer Liste von Schlüsselwortargumenten.
return cls(
query_constructor=query_constructor,
vectorstore=vectorstore,
use_original_query=use_original_query,
structured_query_translator=structured_query_translator,
**kwargs,
)
Zusammenfassung, wie LangChain Self Querying implementiert
In diesem Artikel haben wir behandelt, wie LangChain ein Konzept implementiert, das sie „Self-Querying“ nennen. Es ist eine Möglichkeit, eine einfache Retrieval Augmented Generation (RAG)-Anwendung zu erstellen. Sie verwendet dieselben Komponenten: ein LLM, eine Vektordatenbank und einige Prompts zur Schnittstelle mit dem LLM.
Self Querying ist ein ziemlich großer Codeblock in LangChain, aber dieser Artikel behandelt speziell die Klassenmethode from_llm. Diese Methode ermöglicht es uns, eine RAG-App zu erstellen, indem wir nur vier erforderliche Felder übergeben. Das LLM, die Vektordatenbank, eine Beschreibung der Dokumente und die Metadateninformationen. Möchtest du mehr über LLMs und Vektordatenbanken erfahren? Chatte mit uns auf Discord.
Weiterlesen
Zilliz Cloud Now Available in AWS Asia Pacific (Seoul)
Zilliz Cloud is now available in AWS Seoul — low-latency vector search, in-country data residency, and one-step migration for Korean AI teams. 31 regions across 5 clouds.
How to Build an Enterprise-Ready RAG Pipeline on AWS with Bedrock, Zilliz Cloud, and LangChain
Build production-ready enterprise RAG with AWS Bedrock, Nova models, Zilliz Cloud, and LangChain. Complete tutorial with deployable code.
Why Not All VectorDBs Are Agent-Ready
Explore why choosing the right vector database is critical for scaling AI agents, and why traditional solutions fall short in production.