1br.de

Category: Java

  • LangChain4j mit Qdrant – Schritt-für-Schritt Tutorial für Einsteiger

    Willkommen zum Tutorial zur Integration von Qdrant mit LangChain4j! In diesem Blog-Post lernst du, wie du einen leistungsstarken Vektor-Datenbank-Store für deine KI-Anwendungen einrichtest und nutzt.

    Was du am Ende dieses Tutorials gelernt hast

    Nach diesem Tutorial wirst du wissen:

    • Wie man Qdrant als Embedding-Speicher mit LangChain4j integriert
    • Wie man Dokumente in Qdrant speichert und abfragt
    • Wie man Embeddings mit OpenAI erstellt und in Qdrant speichert
    • Wie man Suchoperationen durchführt, um relevante Informationen zu finden

    Voraussetzungen für das Tutorial

    Bevor du mit dem Tutorial beginnst, benötigst du folgende Voraussetzungen:

    1. Java Development Kit (JDK) 11 oder höher
    2. Gradle Build-Tool (Version 7.x oder höher)
    3. Docker (für die Qdrant Server-Installation)
    4. Ein OpenAI API-Schlüssel (openai.com)
    5. Grundlegende Kenntnisse in Java und Gradle
    6. Ein Code-Editor wie IntelliJ IDEA, VS Code oder Eclipse

    Schritt-für-Schritt-Anleitung

    Schritt 1: Projektstruktur und Abhängigkeiten einrichten

    Zuerst erstellen wir ein neues Gradle-Projekt und fügen die notwendigen Abhängigkeiten hinzu.

    build.gradle

    plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    // LangChain4j core
    implementation 'dev.langchain4j:langchain4j:0.28.0'

    // Qdrant integration
    implementation 'dev.langchain4j:langchain4j-qdrant:0.28.0'

    // OpenAI integration (für Embeddings)
    implementation 'dev.langchain4j:langchain4j-open-ai:0.28.0'

    // Logging
    implementation 'org.slf4j:slf4j-simple:2.0.9'

    testImplementation 'junit:junit:4.13.2'
}

    Warum diese Abhängigkeiten?

    • langchain4j: Die Hauptbibliothek für KI-Anwendungen
    • langchain4j-qdrant: Spezielle Integration für Qdrant Vektor-Datenbank
    • langchain4j-open-ai: Für das Erstellen von Embeddings mit OpenAI
    • slf4j-simple: Einfache Logging-Lösung für Entwicklungszwecke

    Schritt 2: Qdrant Server starten

    Bevor wir mit der Programmierung beginnen, müssen wir den Qdrant-Server starten:

    docker run -p 6333:6333 -p 6334:6334 \
  --name qdrant \
  --restart=always \
  qdrant/qdrant

    Warum Docker?
    Docker ermöglicht es uns, Qdrant schnell und ohne Komplikationen zu installieren. Es ist eine vollständig isolierte Umgebung, in der alle Abhängigkeiten korrekt geladen werden.

    Schritt 3: Grundlegende Implementierung

    Erstelle die Hauptklasse für unsere Qdrant-Integration:

    import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.splitter.RecursiveCharacterTextSplitter;
import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.openai.OpenAiEmbeddingModel;
import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.embedding.qdrant.QdrantEmbeddingStore;

public class QdrantExample {

    public static void main(String[] args) {
        // Embedding-Modell initialisieren
        EmbeddingModel embeddingModel = OpenAiEmbeddingModel.builder()
                .apiKey("your-openai-api-key")
                .modelName("text-embedding-3-small")
                .build();

        // Qdrant Speicher initialisieren
        EmbeddingStore<TextSegment> embeddingStore = QdrantEmbeddingStore.builder()
                .host("localhost")  
                .port(6334)         
                .collectionName("my_collection")
                .build();

        // Dokumente aufteilen
        RecursiveCharacterTextSplitter splitter = new RecursiveCharacterTextSplitter(
                1000,  // chunk size
                200    // chunk overlap
        );

        // Dokumente hinzufügen
        String documentContent = "Dein langer Textinhalt hier...";
        Document document = Document.from(documentContent);
        List<TextSegment> segments = splitter.split(document);

        // Embeddings erstellen und in Qdrant speichern
        List<Embedding> embeddings = embeddingModel.embedAll(segments).content();
        embeddingStore.addAll(embeddings, segments);

        System.out.println("Dokumente erfolgreich gespeichert!");
    }
}

    Schritt 4: Vollständiges Suchbeispiel

    Erstelle eine umfassende Implementierung mit Suchfunktion:

    import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.splitter.RecursiveCharacterTextSplitter;
import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.openai.OpenAiEmbeddingModel;
import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.embedding.qdrant.QdrantEmbeddingStore;

public class QdrantSearchExample {

    public static void main(String[] args) {
        // Embedding-Modell konfigurieren
        EmbeddingModel embeddingModel = OpenAiEmbeddingModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("text-embedding-3-small")
                .build();

        // Qdrant Speicher erstellen
        EmbeddingStore<TextSegment> embeddingStore = QdrantEmbeddingStore.builder()
                .host("localhost")
                .port(6333)
                .collectionName("documents")
                .build();

        // Beispiel-Dokumente hinzufügen
        addDocument(embeddingStore, embeddingModel, "Künstliche Intelligenz ist eine Technologie...");
        addDocument(embeddingStore, embeddingModel, "Machine Learning ist ein Teilbereich der KI...");

        // Suche durchführen
        searchDocuments(embeddingStore, embeddingModel, "Was ist Machine Learning?");
    }

    private static void addDocument(EmbeddingStore<TextSegment> store, 
                                   EmbeddingModel model, String content) {
        // Dokument aufteilen
        RecursiveCharacterTextSplitter splitter = new RecursiveCharacterTextSplitter(1000, 200);
        List<TextSegment> segments = splitter.split(Document.from(content));

        // Embeddings erstellen und speichern
        List<Embedding> embeddings = model.embedAll(segments).content();
        store.addAll(embeddings, segments);
    }

    private static void searchDocuments(EmbeddingStore<TextSegment> store,
                                      EmbeddingModel model, String query) {
        // Query-Embedding erstellen
        Embedding queryEmbedding = model.embed(query).content();

        // Ähnliche Dokumente finden
        List<TextSegment> relevantSegments = store.findRelevant(queryEmbedding, 3);

        // Ergebnisse anzeigen
        System.out.println("Suchergebnisse für: " + query);
        for (TextSegment segment : relevantSegments) {
            System.out.println("- " + segment.text());
        }
    }
}

    Häufige Fehler und wie man sie behebt

    Fehler 1: Verbindung zum Qdrant-Server nicht möglich

    Problem: Die Anwendung meldet “Connection refused” oder ähnliche Verbindungsfehler.

    Lösung:

    1. Überprüfe, ob Docker installiert ist und läuft:
       docker ps
    1. Starte den Qdrant-Container neu:
       docker stop qdrant && docker rm qdrant
   docker run -p 6333:6333 -p 6334:6334 --name qdrant --restart=always qdrant/qdrant
    1. Stelle sicher, dass Port 6333 und 6334 nicht bereits von anderen Anwendungen verwendet werden.

    Fehler 2: OpenAI API-Schlüssel nicht gefunden

    Problem: Die Anwendung wirft eine Fehlermeldung wegen fehlenden API-Schlüssels.

    Lösung:

    1. Erstelle einen API-Schlüssel auf platform.openai.com
    2. Setze den Schlüssel als Umgebungsvariable:
       export OPENAI_API_KEY="dein_sehr_geheimer_schlüssel"
    1. Oder füge ihn direkt in den Code ein (nur für Entwicklung):
       .apiKey("dein_sehr_geheimer_schlüssel")

    Fehler 3: Gradle-Kompilierungsfehler

    Problem: Kompilierungsfehler wie “package not found” oder “version conflict”.

    Lösung:

    1. Synchronisiere deine Gradle-Abhängigkeiten:
       ./gradlew clean build --refresh-dependencies
    1. Überprüfe, ob du die richtige Java-Version verwendest:
       java -version
    1. Stelle sicher, dass alle Abhängigkeiten in der build.gradle korrekt sind.

    Zusammenfassung und nächste Schritte

    In diesem Tutorial hast du gelernt, wie man Qdrant als leistungsstarken Vektor-Datenbank-Speicher für LangChain4j einrichtet. Du hast gesehen, wie man Dokumente in Qdrant speichert, Embeddings generiert und Suchoperationen durchführt.

    Wichtige Punkte, die du gelernt hast:

    • Die Integration von Qdrant mit LangChain4j ist einfach und effizient
    • Embeddings sind der Schlüssel für semantische Suche in KI-Anwendungen
    • Qdrant ermöglicht schnelle und skalierbare Suchoperationen
    • Die Kombination mit OpenAI bietet hochwertige Embeddings

    Nächste Schritte für dich:

    1. Erweitere deine Anwendung: Füge eine Web-Oberfläche hinzu, um die Suchfunktion grafisch darzustellen
    2. Verwende verschiedene Embedding-Modelle: Teste andere Modelle wie BERT oder Sentence Transformers
    3. Implementiere fortgeschrittene Suchoperationen: Wie ReRanking, Filterung und mehr
    4. Skaliere deine Lösung: Erweitere die Anwendung für große Datensätze und mehrere Benutzer