Datenaufnahme

Die Datenerfassung ist der Prozess des Parsens von Informationen aus Quelldokumenten, damit diese in einen Suchraum eingebettet und später abgerufen werden können. Während dies bei Klartext ein unkomplizierter Prozess ist, treten Komplikationen auf, wenn die Quelldokumente in Nicht-Text-Formaten vorliegen, z. B. Microsoft Word oder PDF, und wenn sie komplexe Formatierungen wie wiederholende Kopf- und Fußzeilen, Text in mehreren Spalten oder Tabellen enthalten.

Dieser Abschnitt enthält Tipps, Techniken, Beschleuniger und Hinweise auf Assets, die dabei helfen, diese Herausforderungen zu meistern.

 

Wenn Sie ein Benutzer ohne technische Kenntnisse sind, sind Ihre Dokumente relativ einfach und Sie benötigen eine no-code-Lösung, verwenden Sie Watsonx Orchestrate.

 

Wenn Sie ein technischer Benutzer sind und Ihre Dokumente relativ einfach sind und Sie Zugriff auf Watson Discovery haben, beginnen Sie dort. Watson Discovery hat eine schöne Benutzeroberfläche, die man mit minimalem Bedarf an Codierung nutzen kann. Bei komplexen Dokumenten können Sie Watson Discovery verwenden, um bestimmte Teile Ihrer Dokumente zu annotieren und zu extrahieren, entweder für Ihre RAG-Backend-Pipeline oder für das Frontend, und um die Texte hervorzuheben, indem Sie die genaue Position eines Absatzes innerhalb Ihrer Dokumente ermitteln.

 

Watson Discovery hat jedoch seine Grenzen. Wenn Ihre Dokumente größer als 50 MB sind, können Sie sie nicht in Watson Discovery laden. Wenn das Dokument zu komplex ist (z. B. beinhaltet verschachtelte Tabellen oder unregelmäßige Tabellenformate), Watson Discovery erfasst möglicherweise nicht die gesamte Dokumentstruktur. In solchen Fällen sollten Sie eine benutzerdefinierte Pipeline für die Datenaufnahme mit Hilfe von Open-Source-Bibliotheken implementieren.

 

Im Hinblick auf Open-Source-Bibliotheken sind LangChain und LlamaIndex hinsichtlich ihrer Funktionen bei der Datenaufnahme sehr ähnlich. LangChain wäre jedoch im Hinblick auf Dokumentation und Integration mit Vektordatenbanken und anderen Anwendungen einfacher zu handhaben als LlamaIndex. Sowohl LangChain als auch LlamaIndex verfügen über Hilfsfunktionen, die ein Dokumentobjekt in ein anderes umwandeln können, so dass der Wechsel zwischen LangChain und LlamaIndex an jedem beliebigen Punkt in Ihrer Pipeline erfolgen kann.

Im Folgenden finden Sie einige Lektionen, die wir bei der Aufnahme von Dokumenten mit komplexen Tabellen gelernt haben, sowie verschiedene Ansätze, die bei einem der Aufträge getestet wurden. Bitte beachten Sie, dass einige der Beobachtungen von Engagement zu Engagement unterschiedlich sein können. Die meisten Schlussfolgerungen sollten jedoch für Engagements, die Dokumente mit verschachtelten und komplexen Tabellen umfassen, ähnlich sein.

Watson Discovery

Watson Discovery unterstützt keine Dokumente, die größer als 50 MB sind. In Fällen, in denen die große Größe darauf zurückzuführen ist, dass die Originaldokumente im Word-Format vorliegen, müssen wir die ursprünglichen Word-Dokumente in PDF konvertieren, um Watson Discovery nutzen zu können. Mit diesem Ansatz gelingt es Watson Discovery jedoch manchmal nicht, Tabellenformate richtig zu erfassen, insbesondere bei komplexen oder verschachtelten Tabellen.

Für die Ingestion mit Watson Discovery können zwei verschiedene Ansätze getestet werden: ein vorab trainiertes Modell und ein Benutzermodell, das durch manuelles Kommentieren einiger Seiten über das Smart Document Understanding von Discovery trainiert wurde. Im Folgenden werden die Erfahrungen mit diesen beiden Ansätzen für einen der Aufträge erörtert, der komplexe verschachtelte Tabellen umfasste.

• vortrainiertes Modell
  • Vorteile: 
    • Die HTML-Ausgabe von Discovery konnte die Struktur der Tabellen oft besser erfassen als ein benutzertrainiertes Modell (SDU)
  • Nachteile: 
    • Discovery hatte immer noch Schwierigkeiten, verschachtelte Tabellen zu erkennen. In manchen Fällen sieht es nur die innerste Tabelle als Tabelle und erfasst die äußeren Tabellen als Text, wodurch die Datenstruktur verloren geht.
      
  • Bei der Verwendung von Watson Discovery kann die Verwendung des Rohtextes im Vergleich zur Verwendung von HTML-Ausgaben zu besseren Ergebnissen führen.  

• benutzerdefiniertes Modell
  • Vorteile: 
    • Sehr einfach zu kommentieren und gut geeignet für einfache Dokumente, in denen man später bestimmte Abschnitte herausfiltern möchte.
  • Nachteile:
    • Wir konnten die verschachtelten Tabellenstrukturen nicht erkennen, selbst wenn wir alle Tabellen innerhalb der Tabellen annotiert hätten.
    • Selbst bei einfachen Tabellen hatte es Probleme, diese in neuen Dokumenten zu erkennen; selbst nach der manuellen Annotation von 20 Seiten aus mehr als 7 Dokumenten.

Obwohl die Ergebnisse von Watson Discovery nicht so genau waren wie andere unten erwähnte benutzerdefinierte Bibliotheken für komplexe und verschachtelte Tabellen, enthielten die Ergebnisse viele Metadaten wie Seitenzahlen und Koordinaten der Texte, die hilfreich sind, um die Highlights für die Benutzeroberfläche darzustellen. Diese Metadaten können sehr hilfreich sein, um beim Abruf zusätzliche Filter hinzuzufügen oder die Dokumente anhand bestimmter HTML-Abschnitte aufzuteilen.

PyPDFLoader und PyMuPDF im Vergleich

Die PyMuPDF-Bibliothek ist deutlich schneller und liefert genauere Ergebnisse, insbesondere bei größeren Daten. Bei Verwendung der folgenden zwei Funktionen auf einem 50,6 MB großen Datensatz benötigte PyMuPDF 0,131 Sekunden gegenüber 0,366 Sekunden für PypdfLoader von LangChain. Für große Dateien und wenn Sie nicht einzelne Abschnitte des Dokuments extrahieren möchten, verwenden Sie die PyMuPdf-Bibliothek.

def pdf_to_text(path: str,
                        start_page: int = 1,
                        end_page: Optional[int | None] = None) -> (list[str], list[str], list[dict]):
    """
    Wandelt PDF in Klartext um.

    Params:
        Pfad (STR): Pfad zur PDF-Datei.
        start_page (int): Seite, von der aus der Text abgerufen werden soll.
        end_page (int): Letzte Seite, von der Text empfangen wird.
    """
    logger.debug("Processing PDF %s".format(path))

    from langchain_community.document_loaders import PyPDFLoader

    loader = PyPDFLoader(path)
    pages = loader.load()
    total_pages = len(pages)
    logger.debug(f'Total pages: {total_pages}')
    _ids = []
    _metadata = []
    _file_name = Path(path).name

    if end_page is None:
        end_page = len(pages)

    _text_list = []
    for index in range(start_page - 1, end_page):
        text = pages[index].page_content
        text = text.replace('\n', ' ')
        text = re.sub(r'\s+', ' ', text)
        _text_list.append(text)
        _ids.append(f'page_{index + 1}')
        _metadata.append({
            "id": index + 1,
            "file_name": _file_name,
            "page": f'page {index + 1}'
        })

    return _text_list, _ids, _metadata

def large_pdf_to_text(path: str,
                        start_page: int = 1,
                        end_page: Optional[int | None] = None,
                        remove_string_list=None) -> (list[str], list[str], list[dict]):
    """
        Converts PDF to plain text using PyMuPDF, impressive execution speed, making it suitable for
        large-scale PDF processing. Auch wenn es keine speziellen Funktionen zur Tabellenextraktion bietet, kann es
        dennoch zur Analyse der PDF-Struktur und zur Extraktion tabellarischer Daten mit zusätzlicher Verarbeitung verwendet werden. 50,6 MB -> 0,131 Sekunden (PyMuPDF) und 0,366 Sekunden (pypdf) im Vergleich

        Params:
            file_stream (stream): Stream zur PDF-Datei.
            Pfad (str): Pfad zur PDF
            start_page (int): Seite, von der aus der Text abgerufen werden soll.
            end_page (int): Letzte Seite, von der Text empfangen wird.
            remove_string_list (list[str]): String-Liste entfernen.
        """
    logger.debug("Processing PDF %s".format(path))
    if remove_string_list is None:
        remove_string_list = []

    import fitz

    # pdf_reader = fitz.open(stream = file_stream, filetype = "pdf")
    pdf_reader = fitz.open(path)
    if end_page is None:
        end_page = pdf_reader.page_count

    _text_list = []
    _ids = []
    _metadata = []
    _file_name = Path(path).name
    for index in range(start_page - 1, end_page):
        text = pdf_reader[index].get_text("text")
        text = text.replace('\n', ' ')
        text = re.sub(r'\s+', ' ', text)
        for remove_string in remove_string_list:
            re_compile = re.compile(remove_string)
            text = re_compile.sub('', text)
            _metadata.append({
                "id": index + 1,
                "file_name": _file_name,
                "page": f'page {index + 1}'
            })
        _ids.append(f'page_{index + 1}')
        _text_list.append(text)

    return _text_list, _ids, _metadata

Unstrukturierter PDF-Loader für HTML-Aufnahme UnstructuredPDFLoader von LangChain

• Vorteile: 
  • Enthält viele Metadaten wie Seitenzahlen und x,y-Koordinaten der Texte, ähnlich wie bei Watson Discovery, was später nützlich sein könnte, um Hervorhebungen anzuzeigen.
• Nachteile: 
  • Viele verschachtelte oder komplexe Tabellen konnten nicht korrekt erfasst werden. Außerdem müssten wir für diesen Ansatz jedes der ursprünglichen DOCX-Formate in PDF konvertieren.

Unstrukturierter Wortlader für HTML-Eingabe UnstructuredWordDocumentLoader von LangChain

• Vorteile: 
  • Die Verwendung der Dokumente führte zu einer besseren Erfassung der Tabellen und half den LLMs, einen besseren Kontext für die Generierung von Antworten zu erhalten.
• Nachteile: 
  • Metadaten wie Seitenzahlen wurden im Vergleich zum PDF-Loader auch nach dem Einfügen von Seitenumbrüchen nicht korrekt erfasst.

Zusammenfassung der HTML-Tabelle

Um die Struktur der Tabellen zu erhalten, geben wir Tabellenelemente aus extrahiertem HTML (mithilfe der Unstructured-Bibliothek) in ein LLM ein (Mixtral ist aufgrund seiner Kontextgröße eine gute Option für lange Tabellen). Anschließend können wir eine Eingabe erstellen, um entweder die Tabellen zusammenzufassen oder Few-Shot-Learning zu verwenden, um die Tabellen in ein Format zu konvertieren, von dem wir denken, dass es für die großen Sprachmodelle verständlicher sein könnte.

• Vorteile: 
  • Der Ausgabetext ließe sich leichter zerlegen und aufnehmen und die Struktur der Tabellen bliebe erhalten.
• Nachteile: 
  • Bei großen, mehrseitigen Tabellen kann es passieren, dass wir bei der Eingabe zur Zusammenfassung einige Informationen verlieren, sodass die wenigen Shots, die lernen, die Tabellen zu konvertieren, anstatt sie zusammenzufassen, zu besseren Ergebnissen führen können.

Andere Tabellenleserbibliotheken wie Camelot und Tabula wurden ebenfalls getestet, jedoch waren diese Bibliotheken für komplexe Tabellen nicht so genau wie unstrukturierte, und da sie nur Tabellen innerhalb eines Dokuments erkennen, könnte mehr Vorverarbeitung nötig sein, um sinnvolle Chunks für die großen Sprachmodelle zu erstellen.

Zum Abschluss lässt sich sagen, dass Watson Discovery zwar eine einfache und schnelle Möglichkeit wäre, Dokumente aufzunehmen und viele zusätzliche Metadaten zu erfassen, die beim Erstellen der Benutzeroberfläche hilfreich sein können (zum Beispiel zum Markieren der Passagen), aber die „unstrukturierte“ Bibliothek (die sowohl in LlamaIndex als auch in LangChain Wrapper enthält) könnte die komplexen Tabellen innerhalb der Dokumente genauer erfassen als Watson Discovery. Eine Kombination beider Ansätze kann also für Projekte hilfreich sein, die komplexe Tabellen in ihren Dokumenten enthalten.

Aufnahme mit Watsonx Orchestrate

Die Datenerfassung ohne grafische Benutzeroberfläche kann für Geschäftsanwender schwierig sein, da sie technische Erfahrung und Kenntnisse erfordert. Watsonx Orchestrate beseitigt die Frustration für Geschäftsanwender durch die Implementierung einer Drag-and-Drop-Benutzeroberfläche (UI). Durch Klicken auf den blauen Upload-Button wird die Möglichkeit aktiviert, Dokumente direkt in watsonx Discovery (auch bekannt als Elasticsearch) hochzuladen und zu speichern.

Dadurch können Benutzer ihre Dokumentation direkt in Elasticsearch hochladen, um ihre eigene benutzerdefinierte Wissensdatenbank zu erstellen.

Anstatt die Dokumente direkt in watsonx Discovery zu übertragen, haben Sie auch die Möglichkeit, sich über watsonx Orchestrate mit Watson Discovery zu verbinden. Weitere Details zum Aufnehmen von Daten mit Watson Discovery finden Sie weiter unten.

Watson Discovery

Eines der anderen internen Tools, das für die Datenerfassung verwendet werden kann, ist Watson Discovery. Watson Discovery ist nicht nur ein reines Aufnahmetool und mit ihm können Sie Ihre unstrukturierten Daten aufnehmen, normalisieren, anreichern und durchsuchen. Das untenstehende Bild zeigt die Kernkomponenten und Funktionen von Watson Discovery.

Wie Sie oben sehen können, ist eine der Kernfunktionen von Watson Discovery das Aufnehmen von strukturierten und unstrukturierten Daten in verschiedenen Formaten wie JSON, HTML, PDF, Word und mehr sowie das intelligente Dokumentenverständnis.

Wenn Sie Watson Discovery in Ihrer Umgebung bereitgestellt haben, können Sie Dokumente einfach aufnehmen, indem Sie zunächst ein Projekt erstellen und dann eine Sammlung erstellen, in der Sie Ihre Daten entweder aus lokalem Speicher oder aus einer Cloud wie einem Objektspeicher hochladen können.

Sobald Sie Ihre Sammlung erstellt haben, können Sie im Hamburger-Menü auf die Registerkarte „Sammlungen verwalten“ gehen und dann unter „Identitätsfelder“ auswählen, welche Methode Sie zur Verarbeitung der Dokumente verwenden möchten.

Es gibt drei Möglichkeiten:

• Nur Textextraktion: Dabei werden nur Texte aus den Dokumenten extrahiert.
• Benutzergeschulte Modelle: Wo Sie verschiedene Teile Ihres Dokuments mit benutzerdefinierten Tags annotieren und Ihre eigenen Modelle basierend auf wiederholten, visuellen Mustern in Ihren Dokumenten trainieren können
• Vorab trainierte Modelle: Diese können mithilfe vorab trainierter IBM-Modelle Text extrahieren und Tabellen, Listen und Abschnitte identifizieren.

Es kann eine Weile dauern, bis alle Ihre Dokumente bearbeitet sind. Anschließend können Sie die Watson Discovery API verwenden, um Ihre Daten in Ihrem Code zu lesen und zu nutzen.

Nachfolgend finden Sie einen Beispielcode, der zeigt, wie Sie die API nutzen können, um die Daten aus Ihrer Sammlung auszulesen:

from langchain.docstore.document import Document
import os
import logging
import time
from ibm_watson import DiscoveryV2
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator

WD_PAGE_SIZE = 200
MAX_RETRIES = 2
def get_documents_from_wd(collection_ids=[WD_COLLECTION_ID]):
    
    print("Fetching documents from Watson Discovery")
    documents = []
    
    print("Configuring the WD client")
    authenticator = IAMAuthenticator(WD_API_KEY)
    wd_client = DiscoveryV2(
        version="2023-03-31",
        authenticator=authenticator
    )
    
    print("Setting the WD service URL")
    wd_client.set_service_url(WD_SERVICE_URL)
    
    print("Fetching documents from WD")
    page_id = 0
    retries = 0
    while True:
        try:
            print("Fetching page: " + str(page_id))
            response = wd_client.query(
                project_id=WD_PROJECT_ID,
                collection_ids=collection_ids,
                return_=["text"],
                count=WD_PAGE_SIZE,
                offset=page_id*WD_PAGE_SIZE
            ).get_result()
            if response is None or not isinstance(response, dict):
                print("No query result")
                raise ValueError("No query result")
            if "results" not in response or response["results"] is None or not isinstance(response["results"], list):
                print("No query result 2")
                raise ValueError("No query result")
            results = response["results"]
            if len(results) == 0:
                print("No more results")
                break
            print("Fetched " + str(len(results)) + " documents")
            documents.extend(list(map(lambda result: Document(page_content=result["text"][0],  
                                                              metadata= {"collection_id": WD_COLLECTION_ID, "document_id" : result['document_id']}), results)))
            page_id += 1
        except Exception as error:
            logging.error("Failed to fetch documents from WD", str(error))
            retries += 1
            time.sleep(5)
            if retries > MAX_RETRIES:
                break
            print("Retrying...")
    print("Fetched " + str(len(documents)) + " documents")
    return documents

 

Web Crawl in Watson Discovery

Wenn Sie ein Projekt in Watson Discovery erstellen, können Sie einen Web-Crawl planen, um Informationen von einer bestimmten URL abzurufen. Sie müssen lediglich die Option „Web Crawl“ bei der Auswahl der Datenquelle auswählen und anschließend die URL und den Crawl-Zeitplan angeben.

Danach können Sie die oben genannten Schritte zur Verwaltung Ihrer Sammlung durchführen und die API verwenden, um die Daten aus Ihrer Sammlung zu lesen. Um mehr Details zur Einrichtung von Web Crawl in Watson Discovery zu sehen, können Sie sich dieses Video ansehen.

Weitere Informationen und Funktionen finden Sie auf der Entwicklerseite von Watson Discovery.

Deep Search

Deep Search ist das Open-Source-Toolkit von IBM Forschung für die Ingestion. Deep Search nutzt modernste KI-Methoden, um kontinuierlich große Dokumentensammlungen zu sammeln, zu konvertieren, anzureichern und zu verknüpfen. Sie können es sowohl für öffentliche als auch für proprietäre PDF-Dokumente verwenden.

Deep Search wandelt unstrukturierte PDF-Dokumente präzise und einfach in strukturierte JSON-Dateien um. Es ermöglicht Ihnen, die Wissensextraktion zu automatisieren sowie Ihre proprietären Basismodelle und großen Sprachmodelle feinabzustimmen.

Weitere Informationen zu Deep Search finden Sie hier.

Deep Search kann anstelle von unstrukturierten oder anderen Open-Source-Bibliotheken ein gutes internes Tool zum Lesen komplexer Dokumente sein. Im Repository finden Sie außerdem eine sehr gute Dokumentation mit verschiedenen Beispielen in Form von Python-Notebooks:

Beispiel-Notebooks Deep Search

Aufnahme von Tabellen aus PDFs

Deep Search liefert gute Ergebnisse beim Extrahieren von Tabellen aus PDFs im JSON-Format.

Für die Tests haben wir ein teilweises PDF-Dokument aus dem CIPP verwendet, das drei Seiten umfasst, auf denen jeweils Tabellendaten angezeigt werden. Die beste Leistung von RAG wird in diesem Fall erreicht, indem Deep Sarch verwendet wird, um Tabellen ins JSON-Format zu extrahieren und sie dann in HTML umzuwandeln, um sie in Watson Discovery / watsonx Discovery zu verwenden, anstatt PDFs direkt zu verwenden, PDFs ohne Deep Search in HTML umzuwandeln oder nur das JSON von Deep Search in Watson Discovery / watsonx Discovery zu verwenden. Wir haben festgestellt, dass Watson Discovery in einigen Fällen die falsche Antwort aus der falschen Zelle in der Tabelle auswählt, dafür aber schneller ist; im selben Fall kann Watson Discovery die exakte Antwort innerhalb des Tabellenrasters ermitteln.

IBM Datacap

IBM Datacap ist eine umfassende Lösung für Dokumenten- und Datenerfassung; bietet schnelles, genaues und kostengünstiges Scannen, Klassifizieren, Erkennen, Validieren und Exportieren von Daten und Dokumentenbildern. Es erfasst Dokumente, extrahiert relevante Daten und integriert diese in nachgelagerte Geschäftsprozesse.

Datacap erfasst Papierdokumente über Scanner, Multifunktionsdrucker oder Mobilgeräte und importiert elektronische Dokumente von Dateisystemen, Fax- oder E-Mail-Servern. Es verbessert die Datenextraktion durch Bildverarbeitungsfunktionen wie das Entfernen von Linien, Strichen und Grenzen.

Datacap verwendet optische Zeichenerkennung (OCR), intelligente Zeichenerkennung (ICR) für Handschrift, optische Markierungserkennung (OMR) für Markierungen und Barcodelesen, um Daten effizient zu extrahieren.

Für detaillierte Installations- und Nutzungsanweisungen siehe die IBM Datacap-Dokumentation.

LangChain-Datenlader

LangChain unterstützt verschiedene Arten von Dokumentladern, die Daten aus einer Quelle als Dokumentobjekt von LangChain laden. Ein Dokument-Objekt ist ein Textstück und zugehörige Metadaten, die später problemlos für Chunking und Abruf verwendet werden können.

Derzeit unterstützt LangChain Lader, die entweder ein ganzes Verzeichnis oder verschiedene Dateitypen laden, wie zum Beispiel:

• CSV
• html
• JSON
• Markdown
• Microsoft Office
• PDF

Sie können diese Loader in wenigen Zeilen in Python verwenden. Zum Beispiel können Sie zum Laden eines PDFs folgenden Code verwenden:

from langchain_community.document_loaders import PyPDFLoader

loader = PyPDFLoader("example_data/layout-parser-paper.pdf")
pages = loader.load_and_split()

Bitte lesen Sie die Dokumentation von LangChain , um zu sehen, wie man diese Lader verwendet.

Neben den im obigen Link genannten gibt es weitere Lader, die Daten direkt aus bestimmten Anwendungen wie E-Mail, GitHub, Google Drive usw. laden können. Die Liste aller verschiedenen Loader finden Sie hier.

In Fällen, in denen Sie Dokumente mit komplexen Strukturen, Formaten und Tabellen haben, können Sie die unstrukturierten Lader von LangChain verwenden. Diese Lader verwenden unter der Oberfläche die unstrukturierte Bibliothek, eine der besten Bibliotheken für komplexe Dokumente (in verschiedenen Formaten wie PDF, MSWord, Power Point usw.) und zur Unterteilung der Dokumente in verschiedene Komponenten: LangChain UnstructuredLoader

LlamaIndex-Datenlader

Ähnlich wie LangChain unterstützt auch LlamaIndex verschiedene Arten von Ladern. Eine der einfachsten Möglichkeiten, Daten mit LlamaIndex zu laden, ist die Verwendung des SimpleDirectoryReader. SimpleDirectoryReader unterstützt die folgenden Typen:

• .csv – durch Kommas getrennte Werte
• .docx – Microsoft Word
• .epub – EPUB-E-Book-Format
• .hwp – Hangul Word Processor
• .ipynb - Jupyter Notebook
• .jpeg, .jpg - JPEG-Bild
• .mbox – MBOX-E-Mail-Archiv
• .md - Markdown
• .mp3, .mp4 - Audio und Video
• .pdf – Portable Document Format
• .png – Portable Network Graphics
• .ppt, .pptm, .pptx - Microsoft PowerPoint

Sie können den SimpleDirectoryLoader mithilfe des folgenden Code-Snippets verwenden:

from llama_index.core import SimpleDirectoryReader

reader = SimpleDirectoryReader(input_dir="path/to/directory")
documents = reader.load_data()

Sie können auch bestimmte Erweiterungen hinzufügen, um nur diese Erweiterungen aus dem Verzeichnis zu lesen:

SimpleDirectoryReader(
   input_dir="path/to/directory", required_exts=[".pdf", ".docx"]
)

Für Details zur Nutzung von LlamaIndex Loadern siehe bitte die Dokumentation.

Auch ähnlich wie bei Huggingface können Sie Ihre eigenen benutzerdefinierten Lader erstellen oder die benutzerdefinierten Lader anderer Personen auf llamahub.KI verwenden.

Ein Nachteil von LlamaIndex im Vergleich zu LangChain ist jedoch, dass die Dokumentation und der Community-Support nicht so gut sind wie bei LangChain, sodass das Debuggen Ihres Codes schwieriger sein kann.

Unstrukturiert

Wenn Sie komplexe Dokumente laden, können Sie auch direkt die unstrukturierte Bibliothek verwenden. Die unstrukturierte Bibliothek ist wirklich gut im Lesen und Parsen von Tabellen.

Die unstrukturierte Bibliothek wird auch von den LangChain- und LlamaIndex-Wrappern unterstützt, was die Verwendung für RAG-Pipelines erleichtern könnte, da diese automatisch die Document-Objekte erstellen und zurückgeben. Wenn Ihr Projekt jedoch mehr Anpassungen benötigt und Sie stattdessen direkt die unstrukturierte Bibliothek verwenden möchten, können Sie auf die folgende Dokumentation zurückgreifen: Unstrukturiert.