LangChain / RAG / vektordatabaser · Lektion

Udvikling af brugerdefinerede dokumentindlæsere

Opret skræddersyede dokumentindlæsere, der kan indlæse data fra unikke eller proprietære kilder, som ikke understøttes direkte af LangChain.

Lektion 1 af 411 trin

Udvikling af brugerdefinerede dokumentindlæsere er en gratis LangChain / RAG / vektordatabaser-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i LangChain / RAG / vektordatabaser, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. LangChain / RAG / vektordatabaser-kurset indeholder 4 lektioner i alt.

Hvorfor bruge brugerdefinerede dokumentindlæsere?

LangChain tilbyder mange indbyggede dokumentindlæsere til almindelige formater som PDF-filer, websider og databaser. Men hvad gør du, hvis dine data er anderledes?

Nogle gange møder du:

Proprietære filformater
Interne API'er eller datakilder
Komplekse datastrukturer, der kræver brugerdefineret fortolkning

Det er her, brugerdefinerede dokumentindlæsere virkelig viser deres styrke!

Mød LangChains BaseLoader

For at oprette din egen indlæser nedarver du fra LangChains BaseLoader-klasse. Det er en abstrakt klasse, hvilket betyder, at den angiver en skabelon for, hvad din indlæser skal gøre.

Den vigtigste metode, du skal implementere, er load(). Denne metode henter dine data og omdanner dem til en liste med Document-objekter.

LangChains Document-objekt

Alle data, der behandles af LangChain, især til RAG, standardiseres til Document-objekter. Hvert Document har to hoveddele:

page_content: Det faktiske tekstindhold.
metadata: En ordbog med nøgle-værdi-par, der beskriver dokumentet (f.eks. kildefil, sidetal og forfatter).

Din brugerdefinerede indlæser skal oprette disse Document-objekter ud fra dine særlige data.

Grundlæggende struktur for en brugerdefineret indlæser

Lad os begynde med en meget enkel brugerdefineret indlæser, der kun returnerer en fast tekststreng som et dokument. Det viser den grundlæggende struktur for nedarvning fra BaseLoader og implementering af load().

from langchain_core.documents import Document
from langchain_core.document_loaders import BaseLoader

class MySimpleTextLoader(BaseLoader):
    def load(self):
        content = "This is a custom text document from MySimpleTextLoader."
        doc = Document(page_content=content)
        return [doc]

# Example usage:
if __name__ == "__main__":
    loader = MySimpleTextLoader()
    documents = loader.load()
    for doc in documents:
        print(f"Content: {doc.page_content}")
        print(f"Metadata: {doc.metadata}")

Gør din indlæser dynamisk

En indlæser med en fast tekststreng er ikke særlig nyttig! Indlæsere fra virkeligheden skal modtage parametre som en filsti, en URL eller API-legitimationsoplysninger.

Det kan du opnå ved at tilføje en __init__-metode til din brugerdefinerede indlæserklasse. Det giver dig mulighed for at sende argumenter, når du opretter en instans af din indlæser.

Indlæsning af en "brugerdefineret" logfil

Forestil dig, at du har en simpel logfil fra en applikation (app.log), hvor hver linje er en hændelse. Lad os oprette en brugerdefineret indlæser, der læser denne fil og behandler hver linje som et separat dokument.

For nemheds skyld opretter vi indholdet af en foreløbig app.log-fil direkte i koden.

from langchain_core.documents import Document
from langchain_core.document_loaders import BaseLoader

# Simulate a log file content
log_file_content = (
    "[INFO] User logged in: user123\n"
    "[ERROR] Database connection failed\n"
    "[DEBUG] Processing request for /api/data\n"
    "[INFO] Data retrieved successfully"
)

class CustomLogLoader(BaseLoader):
    def __init__(self, log_data: str):
        self.log_data = log_data.split('\n')

    def load(self):
        documents = []
        for line in self.log_data:
            if line.strip(): # Avoid empty lines
                doc = Document(page_content=line)
                documents.append(doc)
        return documents

# Example usage:
if __name__ == "__main__":
    loader = CustomLogLoader(log_file_content)
    documents = loader.load()
    for i, doc in enumerate(documents):
        print(f"Doc {i+1}: {doc.page_content[:40]}...")

Tilføjelse af omfattende metadata

Metadata er utrolig nyttige! De hjælper LLM'en med at forstå tekstens kontekst og kan bruges til filtrering eller forbedring af genfindingen. I vores eksempel med en logfil kan det være meget nyttigt at kende det oprindelige loglinjenummer eller kildefilen.

Du kan tilføje alle relevante oplysninger som nøgle-værdi-par i metadata-ordbogen for et Document.

Logindlæser med metadata

Lad os forbedre vores CustomLogLoader, så den medtager metadata som den oprindelige kilde og linjenummeret for hver logpost. Det gør de hentede oplysninger langt mere omfattende!

from langchain_core.documents import Document
from langchain_core.document_loaders import BaseLoader

# Simulate a log file content
log_file_content = (
    "[INFO] User logged in: user123\n"
    "[ERROR] Database connection failed\n"
    "[DEBUG] Processing request for /api/data\n"
    "[INFO] Data retrieved successfully"
)

class CustomLogLoaderWithMeta(BaseLoader):
    def __init__(self, log_data: str, source_name: str = "app.log"):
        self.log_data = log_data.split('\n')
        self.source_name = source_name

    def load(self):
        documents = []
        for i, line in enumerate(self.log_data):
            if line.strip():
                metadata = {
                    "source": self.source_name,
                    "line_number": i + 1
                }
                doc = Document(page_content=line, metadata=metadata)
                documents.append(doc)
        return documents

# Example usage:
if __name__ == "__main__":
    loader = CustomLogLoaderWithMeta(log_file_content, "my_custom_app_logs")
    documents = loader.load()
    for i, doc in enumerate(documents):
        print(f"Doc {i+1}:")
        print(f"  Content: {doc.page_content[:40]}...")
        print(f"  Metadata: {doc.metadata}")

Integration af brugerdefinerede dokumenter

Når din brugerdefinerede indlæser producerer Document-objekter, fungerer de præcis som dokumenter, der er indlæst af enhver anden LangChain-indlæser.

Du kan derefter sende dem videre til de efterfølgende trin i din RAG-pipeline:

Tekstopdeling: Opdel store dokumenter i mindre tekststykker.
Indlejringer: Omdan tekststykker til numeriske vektorer.
Vektorlagre: Gem disse indlejringer, så lighedssøgning bliver effektiv.

Dine brugerdefinerede data er nu klar til avancerede LLM-applikationer!

Hurtigt tjek: Brugerdefinerede indlæsere

Du er ved at bygge en brugerdefineret dokumentindlæser til LangChain. Hvilket af følgende udsagn er SANDT om det Document-objekt, du skal returnere?

Besvar den i den interaktive lektion

Opsummering: Brugerdefinerede dokumentindlæsere

Godt klaret! Du har lært, hvordan du udvikler brugerdefinerede dokumentindlæsere i LangChain.

Du nedarver fra BaseLoader og implementerer metoden load().
Din indlæser omdanner særlige data til en liste med Document-objekter.
Document-objekter indeholder page_content og en fleksibel metadata-ordbog.
Brugerdefinerede indlæsere er afgørende for integration af proprietære datakilder i dine RAG-applikationer.

Dernæst udforsker vi, hvordan du integrerer brugerdefinerede indlejringsmodeller!

Gratis at komme i gang

Lær LangChain / RAG / vektordatabaser med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Udvikling af brugerdefinerede dokumentindlæsere” gratis?

Ja — hele teksten til “Udvikling af brugerdefinerede dokumentindlæsere” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af LangChain / RAG / vektordatabaser-kurset, skal du opgradere til CoddyKit PRO. LangChain / RAG / vektordatabaser-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Udvikling af brugerdefinerede dokumentindlæsere”?

Opret skræddersyede dokumentindlæsere, der kan indlæse data fra unikke eller proprietære kilder, som ikke understøttes direkte af LangChain. Du øver dig i LangChain / RAG / vektordatabaser med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på LangChain / RAG / vektordatabaser?

Der kræves ingen tidligere erfaring. LangChain / RAG / vektordatabaser på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Udvikling af brugerdefinerede dokumentindlæsere”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne LangChain / RAG / vektordatabaser-lektion?

Ja. Alle LangChain / RAG / vektordatabaser-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Udvikling af brugerdefinerede dokumentindlæsere
Integration af brugerdefinerede embedding-modeller
Udvidelse af retrieval-kæder med brugerdefineret logik
Opret brugerdefinerede outputparsere

← Tilbage til LangChain / RAG / vektordatabaser