Implementieren Sie agentenbasiertes Chunking zur Optimierung von LLM-Eingaben mit Langchain und watsonx.ai®

Autor

Shalini Harkar

Lead AI Advocate

Was ist agentenbasiertes Chunking?

Die Art und Weise, wie Sprachmodelle Text verarbeiten und segmentieren, wandelt sich vom traditionellen statischen Ansatz hin zu einem besseren, reaktionsfähigeren Prozess. Anders als beim traditionellen Fixed-Size-Chunking, bei dem große Dokumente an festen Punkten in Chunks unterteilt werden, kommen beim agentenbasierten Chunking KI-basierte Techniken zum Einsatz. Diese analysieren die Inhalte in einem dynamischen Prozess und finden so den besten Weg für die Segmentierung des Textes.

Beim agentischen Chunking kommen KI-basierte Textteilungsmethoden, rekursives Chunking und Chunk-Overlapping-Methoden zum Einsatz. Dieser Ansatz verbessert die Chunking-Fähigkeit, behält Verbindungen zwischen wichtigen Ideen bei und optimiert gleichzeitig kontextuelle Fenster in Echtzeit. Beim agentenbasierten Chunking werden alle Blöcke mit Metadaten angereichert. Dadurch verbessert sich die Abrufgenauigkeit und die Gesamteffizienz des Modells. Dies ist insbesondere bei RAG-Anwendungen wichtig, da sich die Segmentierung der Daten direkt auf die Qualität der Abfrage und die Kohärenz der Antwort auswirken kann. Da in allen kleineren Chunks ein aussagekräftiger Kontext erhalten bleibt, ist dieser Ansatz für Chatbots, Wissensdatenbanken und Anwendungsfälle für generative KI (Gen KI) von großer Bedeutung. Durch Frameworks wie Langchain oder LlamaIndex wird die Retrieval-Effizienz weiter verbessert, wodurch sich diese Methode als äußerst effektiv erweist. 

Schlüsselelemente beim agentenbasierten Chunking

1. Adaptive Chunking-Strategie: Wählen Sie basierend auf der Art des Inhalts, der Absicht hinter der Abfrage und den Abrufanforderungen dynamisch die beste Chunking-Methode aus, um eine effektive Segmentierung zu gewährleisten.

2. Dynamische Chunk-Dimensionierung: Die Chunk-Größen werden in Echtzeit unter Berücksichtigung der semantischen Struktur und des Kontexts geändert, anstatt feste Token-Limits einzuhalten.

3. Kontextbewusste Überlappung: Es erfolgt eine intelligente Bewertung der Überlappungen zwischen Textabschnitten, um die Kohärenz zu wahren und den Verlust wichtiger Informationen zu vermeiden. Dadurch wird die Effizienz beim Abrufen verbessert.

 

Die neuesten KI-Trends, präsentiert von Experten

Erhalten Sie kuratierte Einblicke in die wichtigsten – und faszinierendsten – KI-Neuheiten. Abonnieren Sie unseren wöchentlichen Think-Newsletter. Weitere Informationen in der IBM Datenschutzerklärung.

Vielen Dank! Sie haben ein Abonnement abgeschlossen.

Ihr Abonnement wird auf Englisch geliefert. In jedem Newsletter finden Sie einen Abmeldelink. Hier können Sie Ihre Abonnements verwalten oder sich abmelden. Weitere Informationen finden Sie in unserer IBM Datenschutzerklärung.

Vorteile von agentenbasiertem Chunking gegenüber herkömmlichen Methoden

Agentenbasiertes Chunking bietet Vorteile gegenüber dem traditionellen Chunking:

a. Kontext bleibt erhalten: Es werden wichtige Informationen ohne unnötige Unterbrechungen beibehalten.

b. Intelligente Dimensionierung: Die Chunk-Grenzen werden je nach Bedeutung und Signifikanz angepasst.

c. Abfrageoptimierung: Die Chunks werden kontinuierlich verfeinert, um sie an spezifische Abfragen anzupassen.

d. Effiziente Abfragen: Die Ausgabe von Such- und RAG-Systemen wird verbessert, indem unnötige Fragmentierung minimiert wird.

 

In diesem Tutorial experimentieren Sie mit einer agentenbasierten Chunking-Strategie, indem Sie das IBM Granite-3.0-8B-Instruct-Modell verwenden, das jetzt auf watsonx.ai verfügbar ist. Das Gesamtziel besteht darin, effizientes Chunking durchzuführen, um RAG effektiv zu implementieren.

Voraussetzung

Sie benötigen ein IBM Cloud-Konto, um einen watsonx.ai-Projektzu erstellen.

Schritte

Schritt 1. Richten Sie Ihre Umgebung ein.

Sie können zwar aus mehreren Tools wählen, aber dieses Tutorial führt Sie durch die Einrichtung eines IBM® Kontos für die Verwendung eines Jupyter Notebook.

  1. Melden Sie sich mit Ihrem IBM Cloud-Konto bei watsonx.ai an.

  2. Erstellen Sie ein watsonx.ai-Projekt.
    Sie können Ihre Projekt-ID in Ihrem Projekt abrufen. Klicken Sie auf die Registerkarte „Verwalten“. Kopieren Sie dann die Projekt-ID aus dem Abschnitt „Details“ der Seite „Allgemein“. Sie benötigen diese ID für dieses Tutorial.

  3. Erstellen Sie ein Jupyter Notebook.

Dieser Schritt öffnet eine Notebook-Umgebung, in die Sie den Code aus diesem Tutorial kopieren können. Alternativ können Sie dieses Notebook auf Ihr lokales System herunterladen und als Asset in Ihr watsonx.ai-Projekt hochladen. Weitere Granite-Tutorials finden Sie in der IBM Granite-Community. Dieses Jupyter Notebook sowie die verwendeten Datensätze sind auf GitHub zu finden.

Schritt 2. Richten Sie eine watsonx.ai Laufzeit-Instanz und einen API-Schlüssel ein.

  1. Erstellen Sie eine watsonx.ai-Laufzeit-Service-Instanz (wählen Sie Ihre entsprechende Region aus und wählen Sie den Lite-Plan, der eine kostenlose Instanz ist).

  2. Generieren Sie einen API-Schlüssel.

  3. Verknüpfen Sie die Instanz des watsonx.ai-Runtime-Service mit dem Projekt, das Sie in watsonx.ai erstellt haben.

Schritt 3. Installieren und importieren Sie relevante Bibliotheken und richten Sie Ihre Zugangsdaten ein.

Für dieses Tutorial benötigen Sie einige Bibliotheken und Module. Stellen Sie sicher, dass Sie die folgenden importieren. Falls sie nicht installiert sind, kann eine schnelle Pip-Installation das Problem beheben.

Hinweis: Dieses Tutorial wurde mit Python 3.12.7 erstellt

!pip install -q langchain langchain-ibm langchain_experimental langchain-text-splitters langchain_chroma transformers bs4 langchain_huggingface sentence-transformers
import getpass
import requests
from bs4 import BeautifulSoup
from langchain_ibm import WatsonxLLM
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_community.document_loaders import WebBaseLoader
from langchain.schema import SystemMessage, HumanMessage
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.prompts import ChatPromptTemplate
from langchain.vectorstores import Chroma
from langchain.tools import tool
from langchain.agents import AgentExecutor
from langchain.memory import ConversationBufferMemory
from transformers import AutoTokenizer
from ibm_watsonx_ai.foundation_models.utils.enums import EmbeddingTypes
from ibm_watsonx_ai.metanames import GenTextParamsMetaNames as GenParams
from langchain.output_parsers import CommaSeparatedListOutputParser
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.schema import Document
from langchain.chains.combine_documents import create_stuff_documents_chain



 

Um unsere Zugangsdaten festzulegen, benötigen wir „WATSONX_APIKEY“ und „WATSONX_PROJECT_ID“ . Wir legen auch die URL fest, die als API-Endpunkt dient.

load_dotenv(os.getcwd()+"/.env", override=True)
credentials = {
    "url": "https://us-south.ml.cloud.ibm.com",
    "apikey": os.getenv("WATSONX_APIKEY", ""),
}
project_id = os.getenv("PROJECT_ID", "")

Schritt 4. Initialisieren Sie Ihr Sprachmodell. 

Für dieses Tutorial empfehlen wir die Verwendung des IBM Granite-3.0-8B-Instruct-Modell als LLM, um ähnliche Ergebnisse zu erzielen. Sie können jedes KI-Modell Ihrer Wahl verwenden. Die über watsonx verfügbaren Foundation Models finden Sie hier

llm = WatsonxLLM(
    model_id="ibm/granite-3-8b-instruct",
    url=credentials.get("url"),
    apikey=credentials.get("apikey"),
    project_id=project_id,
    params={
        GenParams.DECODING_METHOD: "greedy",
        GenParams.TEMPERATURE: 0,
        GenParams.MIN_NEW_TOKENS: 5,
        GenParams.MAX_NEW_TOKENS: 250,
        GenParams.STOP_SEQUENCES: ["Human:", "Observation"],
    },
)

 Schritt 5. Laden Sie Ihr Dokument.

Diese Funktion extrahiert den Textinhalt von IBMs Erläuterungsseite zum maschinellen Lernen. Diese Funktion entfernt unerwünschte HTML-Elemente (Skripte, Stile) und gibt sauberen, lesbaren Text zurück.

def get_text_from_url(url):
    response = requests.get(url)
    if response.status_code != 200:
        raise ValueError(f"Failed to fetch the page, status code: {response.status_code}")
    soup = BeautifulSoup(response.text, "html.parser")
    for script in soup(["script", "style"]):
        script.decompose()
    return soup.get_text(separator="\n", strip=True)
url = "https://www.ibm.com/de-de/think/topics/machine-learning"
web_text = get_text_from_url(url)
web_text

Statt eine Chunking-Methode mit fester Länge zu verwenden, haben wir ein LLM genutzt, um den Text basierend auf seiner Bedeutung aufzuteilen. Mithilfe dieser Funktion teilt ein LLM Text basierend auf Themen intelligent in semantisch bedeutsame Abschnitte auf.

def agentic_chunking(text):
    """
    Dynamically splits text into meaningful chunks using LLM.
    """
    system_message = SystemMessage(content="You are an AI assistant helping to split text into meaningful chunks based on topics.")
    
    human_message = HumanMessage(content=f"Please divide the following text into semantically different, separate and meaningful chunks:\n\n{text}")

    response = llm.invoke([system_message, human_message]) # LLM returns a string
    return response.split("\n\n") # Split based on meaningful sections
chunks = agentic_chunking(web_text)
chunks

Um ein besseres Verständnis ihrer Ausgabestruktur zu erhalten, drucken wir die Chunks aus.

for i, chunk in enumerate(chunks,1):
    print(f"Chunk {i}:\n{chunk}\n{'-'*40}")

Großartig! Die Chunks wurden von den Agenten in der Ausgabe erfolgreich erstellt.

Schritt 6: Erstellen Sie einen Vektorspeicher.

Nachdem wir mit dem agentenbasierten Chunking des Texts experimentiert haben, setzen wir unsere RAG-Implementierung fort.

In diesem Tutorial wählen wir die von den Agenten erzeugten Chunks aus und konvertieren sie in Vektoreinbettungen. Ein Open-Source-Vektorspeicher, den wir verwenden können, ist Chroma DB. Über das Paket langchain_chrona können wir ganz einfach auf die Chroma-Funktionalität zugreifen. Zunächst initialisieren wir unsere Chroma-Vektordatenbank, fügen unsere Einbettungen hinzu und ergänzen die mit agentenbasierten Chunking erstellten Dokumente.

embeddings_model = HuggingFaceEmbeddings(model_name="ibm-granite/granite-embedding-30m-english")
 

Erstellen Sie eine Chroma-Vektordatenbank.

vector_db = Chroma(
    collection_name="example_collection",
    embedding_function=embeddings_model
)

Konvertieren Sie jeden Chunk in ein Dokumentobjekt.

documents = [Document(page_content=chunk) for chunk in chunks]

Fügen Sie die Dokumente zur Vektordatenbank hinzu.

vector_db.add_documents(documents)

Schritt 7: Strukturieren Sie die Prompt-Vorlage.

Jetzt können wir eine Prompt-Vorlage für unser LLM erstellen. Diese Vorlage stellt sicher, dass wir mehrere Fragen stellen können und gleichzeitig eine einheitliche Prompt-Struktur beibehalten. Zusätzlich können wir unseren Vektorspeicher als Retriever integrieren und damit das RAG-Framework fertigstellen.

prompt_template = """<|start_of_role|>user<|end_of_role|>Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.
{context}
Question: {input}<|end_of_text|>
<|start_of_role|>assistant<|end_of_role|>"""
qa_chain_prompt = PromptTemplate.from_template(prompt_template)
combine_docs_chain = create_stuff_documents_chain(llm, qa_chain_prompt)
rag_chain = create_retrieval_chain(vector_db.as_retriever(), combine_docs_chain)

Schritt 8: Starten Sie den Prozess der RAG-Kette.

Mit diesen Chunks im RAG-Workflow starten wir eine Benutzerabfrage. Zunächst können wir das Modell ohne zusätzlichen Kontext aus dem von uns erstellten Vektorspeicher strategisch ansprechen, um zu testen, ob es sein eingebautes Wissen nutzt oder den RAG-Kontext. Mit der Erläuterun zum maschinellen Lernen von IBM im Hintergrund stellen wir nun die Frage.

output = llm.invoke("What is Model optimization process")
output

Es ist klar, dass das Modell nicht auf Informationen über den Modelloptimierungsprozess trainiert wurde und ohne externe Tools oder Informationen kann es uns nicht die richtigen Informationen liefern. Das Model halluziniert. Versuchen wir nun, die gleiche Abfrage an die RAG-Kette mit den von uns erstellten agentenbasierten Chunks bereitzustellen.

rag_output = rag_chain.invoke({"input": "What is Model optimization process?"})
rag_output['answer']

Großartig! Das Granite-Modell hat die agentenbasierten RAG-Chunks korrekt als Kontext verwendet, um uns die korrekten Informationen über den Modelloptimierungsprozess zu liefern und gleichzeitig die semantische Kohärenz zu wahren.

Zusammenfassung

In diesem Tutorial haben wir mithilfe von KI-Agenten im Chunking-Prozess kleinere Teile relevanter Informationen generiert und eine RAG-Pipeline (Retrieval-Augmented Generation) aufgebaut.

Mithilfe dieser Methode wird die Informationsbeschaffung sowie die Optimierung von Kontextfenstern durch den Einsatz von künstlicher Intelligenz und Verarbeitung natürlicher Sprache (NLP) verbessert. Sie rationalisiert Datenblöcke, um die Abrufeffizienz zu steigern, wenn große Sprachmodelle (LLMs) wie die GPT-Modelle von OpenAI für bessere Ergebnisse genutzt werden.

Weiterführende Lösungen
Entwicklung von IBM KI-Agenten 

Ermöglichen Sie Entwicklern die Erstellung, Bereitstellung und Überwachung von KI-Agenten mit dem IBM watsonx.ai Studio.

watsonx.ai erkunden
IBM KI-Agenten und -Assistenten

Erzielen Sie bahnbrechende Produktivität mit einem der branchenweit umfassendsten Funktionenpakete, das Unternehmen bei der Erstellung, Anpassung und Verwaltung von KI-Agenten und KI-Assistenten unterstützt. 

Erkunden Sie KI-Agenten
IBM Granite

Erzielen Sie Kosteneinsparungen von über 90 % mit den kleineren und offenen Modellen von Granite, die auf Entwicklereffizienz ausgelegt sind. Diese auf Unternehmen abgestimmten Modelle bieten eine herausragende Leistung bei Sicherheitsbenchmarks und in einem breiten Spektrum von Unternehmensaufgaben von Cybersicherheit bis RAG.

Granite erkunden
Machen Sie den nächsten Schritt

Automatisieren Sie Ihre komplexen Workflows und erzielen Sie bahnbrechende Produktivität mit einem der branchenweit umfassendsten Funktionspakete, das Unternehmen bei der Erstellung, Anpassung und Verwaltung von KI-Agenten und KI-Assistenten unterstützt. 

watsonx.ai Agentenentwicklung erkunden Entdecken Sie watsonx Orchestrate