LLM-applikasjoner i produksjon (RAG + vektordatabase + hurtigbufring) · leksjon

Integrasjon med en vektordatabase

Lær å koble RAG-applikasjonen til en vektordatabase som Pinecone, Weaviate eller Chroma, og utføre indeksering og spørringer.

Leksjon 3 av 412 trinn

Integrasjon med en vektordatabase er en gratis leksjon i LLM-applikasjoner i produksjon (RAG + vektordatabase + hurtigbufring) på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i LLM-applikasjoner i produksjon (RAG + vektordatabase + hurtigbufring), og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i LLM-applikasjoner i produksjon (RAG + vektordatabase + hurtigbufring) inneholder totalt 4 leksjoner.

Koble sammen RAG og vektordatabaser

Velkommen til den siste leksjonen i kurset vårt «Dykk ned i vektordatabaser»! De har lært hvorfor vektordatabaser er avgjørende for RAG-systemer, og hva vektor-embeddinger er.

Nå skal vi samle trådene. Denne leksjonen fokuserer på de praktiske trinnene for å integrere en vektordatabase i RAG-applikasjonen Deres.

Vi skal dekke:

Koble til en klient for vektordatabasen.
Klargjøre dataene for lagring.
Indeksere (legge til) dataene.
Spørre databasen (søke) etter relevant informasjon.

Vektordatabaser i RAG: En rask oppsummering

Før vi går inn på integrasjonen, skal vi raskt repetere hvilken rolle vektordatabaser spiller i RAG.

Dette er spesialiserte databaser som er utviklet for å lagre og effektivt søke i vektor-embeddinger. Disse embeddingene er numeriske representasjoner av tekst, bilder eller andre data, og fanger opp den semantiske betydningen deres.

Når en bruker stiller et spørsmål, konverterer vi det til en embedding, søker i vektordatabasen etter lignende dokumentembeddinger og henter de mest relevante informasjonsdelene. Denne konteksten sendes deretter til LLM-en.

Velge et klientbibliotek

For å samhandle med en vektordatabase bruker De det offisielle klientbiblioteket. Disse bibliotekene tilbyr metoder for å koble til, legge til data, utføre spørringer og administrere indeksen.

Populære alternativer omfatter:

Pinecone Client: For Pinecones skybaserte vektordatabase.
ChromaDB Client: For Chroma, en vektordatabase med åpen kildekode som ofte brukes lokalt eller på egen server.
Weaviate Client: For Weaviate, en annen populær vektordatabase med åpen kildekode og skybasert drift.

Alle klientene følger et lignende mønster for tilkobling og utføring av operasjoner.

Opprette en tilkobling

Det første trinnet er alltid å opprette en tilkobling til vektordatabasen. Dette innebærer vanligvis å initialisere et klientobjekt med API-nøkkelen, miljødetaljer eller vertsadressen Deres.

For å demonstrere dette bruker vi en forenklet SimpleVectorDB-klasse som etterligner operasjoner i ekte vektordatabaser. Prøv å kjøre dette eksempelet for å se hvordan en klient kan initialiseres.

import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;

class SimpleVectorDB {
    private String apiKey;
    private String environment;

    public SimpleVectorDB(String apiKey, String environment) {
        this.apiKey = apiKey;
        this.environment = environment;
        System.out.println("SimpleVectorDB client initialized!");
        System.out.println("API Key (masked): ****" + apiKey.substring(apiKey.length() - 4));
        System.out.println("Environment: " + environment);
    }

    // Placeholder for other methods like upsert, query
}

public class Main {
    public static void main(String[] args) {
        String myApiKey = "sk_your_actual_api_key";
        String myEnvironment = "gcp-starter";

        // Initialize the vector database client
        SimpleVectorDB dbClient = new SimpleVectorDB(myApiKey, myEnvironment);
    }
}

Forstå datastrukturen

Når De legger til data i en vektordatabase, forventer den vanligvis tre hovedkomponenter for hvert element:

ID: En unik identifikator for dokumentdelen Deres (for eksempel «doc123-chunk4»).
Vektor: Den numeriske embeddingen (en liste med flyttall) for tekstutdraget Deres.
Metadata: Valgfrie, men svært nyttige nøkkel-verdi-par (for eksempel kildedokument, sidetall eller forfatter) som gir ekstra kontekst og muliggjør filtrering under spørringer.

Denne strukturen hjelper databasen med å administrere og hente informasjonen Deres effektivt.

Klargjøre data for indeksering

Før De kan indeksere data, må De klargjøre dem. Dette innebærer:

Laste inn data: Hente råtekst fra ulike kilder (PDF-filer, nettsider eller databaser).
Dele opp i deler: Dele lange dokumenter opp i mindre, semantisk meningsfulle deler.
Embedding: Konvertere hver tekstdel til den tilhørende vektor-embeddingen ved hjelp av en embeddingmodell.

I denne leksjonen antar vi at De allerede har tekstdelene og embeddingene deres klare for indeksering. Fokuset her er på samhandlingen med selve vektordatabasen.

Indeksere dokumenter (upsert)

Prosessen med å legge til eller oppdatere vektorer og tilknyttede metadata i en vektordatabase kalles ofte upserting. Det tilsvarer innsetting hvis ID-en er ny, eller oppdatering hvis ID-en allerede finnes.

La oss utvide SimpleVectorDB med en upsert-metode og legge til noen eksempeldata. Legg merke til at hvert element har en ID, en vektor og metadata.

import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;

class SimpleVectorDB {
    private String apiKey;
    private String environment;
    // In-memory store for demonstration
    private Map<String, Map<String, Object>> index = new HashMap<>();

    public SimpleVectorDB(String apiKey, String environment) {
        this.apiKey = apiKey;
        this.environment = environment;
        System.out.println("SimpleVectorDB client initialized!");
    }

    public void upsert(List<Map<String, Object>> vectorsToUpsert) {
        System.out.println("Upserting " + vectorsToUpsert.size() + " vectors...");
        for (Map<String, Object> item : vectorsToUpsert) {
            String id = (String) item.get("id");
            index.put(id, item);
            System.out.println("  Upserted ID: " + id + ", Metadata: " + item.get("metadata"));
        }
        System.out.println("Upsert complete. Total indexed items: " + index.size());
    }
}

public class Main {
    public static void main(String[] args) {
        String myApiKey = "sk_your_actual_api_key";
        String myEnvironment = "gcp-starter";
        SimpleVectorDB dbClient = new SimpleVectorDB(myApiKey, myEnvironment);

        // Sample data for indexing
        List<Map<String, Object>> data = new ArrayList<>();
        data.add(new HashMap<String, Object>() {{
            put("id", "doc1-chunk1");
            put("vector", Arrays.asList(0.1f, 0.2f, 0.3f, 0.4f));
            put("metadata", new HashMap<String, String>() {{ put("source", "report.pdf"); put("page", "1"); }});
        }});
        data.add(new HashMap<String, Object>() {{
            put("id", "doc1-chunk2");
            put("vector", Arrays.asList(0.5f, 0.6f, 0.7f, 0.8f));
            put("metadata", new HashMap<String, String>() {{ put("source", "report.pdf"); put("page", "2"); }});
        }});

        dbClient.upsert(data);
    }
}

Utføre et likhetssøk

Når dataene er indeksert, kan De utføre spørringer. En spørring innebærer vanligvis:

Konvertere brukerens spørsmål til en spørringsembedding.
Sende denne spørringsembeddingen til vektordatabasen.
Databasen finner de «k» mest like vektorene (dokumentdelene) basert på embeddingene deres.
Den returnerer disse dokumentdelene sammen med de tilknyttede metadataene.

Dette er selve kjernen i hvordan RAG henter relevant kontekst!

Kodeeksempel på spørring

La oss legge til en query-metode i SimpleVectorDB og simulere et søk. For enkelhets skyld returnerer den simulerte spørringen bare det mest «like» elementet basert på en svært enkel samsvarslogikk (i en ekte database er dette en kompleks likhetsalgoritme).

Se for Dem at en bruker stiller et spørsmål, og at embeddingen for dette spørsmålet er vår queryVector.

import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

class SimpleVectorDB {
    private String apiKey;
    private String environment;
    private Map<String, Map<String, Object>> index = new HashMap<>();

    public SimpleVectorDB(String apiKey, String environment) {
        this.apiKey = apiKey;
        this.environment = environment;
    }

    public void upsert(List<Map<String, Object>> vectorsToUpsert) {
        for (Map<String, Object> item : vectorsToUpsert) {
            index.put((String) item.get("id"), item);
        }
        System.out.println("Upsert complete. Total indexed items: " + index.size());
    }

    // Simple similarity (Euclidean distance for demo)
    private double calculateSimilarity(List<Float> vec1, List<Float> vec2) {
        double sumSqDiff = 0;
        for (int i = 0; i < vec1.size(); i++) {
            sumSqDiff += Math.pow(vec1.get(i) - vec2.get(i), 2);
        }
        return -Math.sqrt(sumSqDiff); // Smaller distance = higher similarity
    }

    public List<Map<String, Object>> query(List<Float> queryVector, int topK) {
        System.out.println("Querying for top " + topK + " similar vectors...");
        List<Map<String, Object>> results = new ArrayList<>();
        List<Map.Entry<String, Map<String, Object>>> sortedEntries = new ArrayList<>(index.entrySet());

        sortedEntries.sort(new Comparator<Map.Entry<String, Map<String, Object>>>() {
            @Override
            public int compare(Map.Entry<String, Map<String, Object>> e1, Map.Entry<String, Map<String, Object>> e2) {
                List<Float> vec1 = (List<Float>) e1.getValue().get("vector");
                List<Float> vec2 = (List<Float>) e2.getValue().get("vector");
                return Double.compare(calculateSimilarity(queryVector, vec2), calculateSimilarity(queryVector, vec1));
            }
        });

        for (int i = 0; i < Math.min(topK, sortedEntries.size()); i++) {
            results.add(sortedEntries.get(i).getValue());
        }
        return results;
    }
}

public class Main {
    public static void main(String[] args) {
        String myApiKey = "sk_your_actual_api_key";
        String myEnvironment = "gcp-starter";
        SimpleVectorDB dbClient = new SimpleVectorDB(myApiKey, myEnvironment);

        List<Map<String, Object>> data = new ArrayList<>();
        data.add(new HashMap<String, Object>() {{
            put("id", "doc1-chunk1");
            put("vector", Arrays.asList(0.1f, 0.2f, 0.3f, 0.4f));
            put("metadata", new HashMap<String, String>() {{ put("source", "report.pdf"); put("page", "1"); }});
        }});
        data.add(new HashMap<String, Object>() {{
            put("id", "doc1-chunk2");
            put("vector", Arrays.asList(0.5f, 0.6f, 0.7f, 0.8f));
            put("metadata", new HashMap<String, String>() {{ put("source", "report.pdf"); put("page", "2"); }});
        }});
        data.add(new HashMap<String, Object>() {{
            put("id", "doc2-chunk1");
            put("vector", Arrays.asList(0.15f, 0.25f, 0.35f, 0.45f)); // Similar to chunk1
            put("metadata", new HashMap<String, String>() {{ put("source", "article.txt"); put("topic", "AI"); }});
        }});

        dbClient.upsert(data);

        // Simulate a query vector (from a user's question)
        List<Float> queryVector = Arrays.asList(0.12f, 0.22f, 0.32f, 0.42f);
        List<Map<String, Object>> queryResults = dbClient.query(queryVector, 2);

        System.out.println("\nQuery Results:");
        for (Map<String, Object> result : queryResults) {
            System.out.println("  ID: " + result.get("id") + ", Metadata: " + result.get("metadata"));
        }
    }
}

Håndtere spørringsresultater

Resultatene fra en spørring mot en vektordatabase er vanligvis en liste med dokumentdeler, rangert etter likhet med spørringen. Hvert resultat inneholder vanligvis:

Den opprinnelige ID-en til delen.
Tekstinnholdet (hvis det er lagret i metadata eller hentes separat ved hjelp av ID-en).
Metadataene som er knyttet til delen.
En likhetsskår eller et avstandsmål.

RAG-applikasjonen Deres tar deretter de øverste k hentede delene, formaterer dem og sender dem som kontekst til den store språkmodellen, som genererer et informert svar.

Rask sjekk: Integrasjon av vektordatabase

De har lært de viktigste trinnene for å integrere en vektordatabase. Hvilken av følgende rekkefølger er den riktige rekkefølgen for operasjonene når nye tekstdata legges til i en RAG-systems vektordatabase?

Besvar den i den interaktive leksjonen

Oppsummering: Integrering av vektordatabaser

Godt jobbet! I denne leksjonen avmystifiserte vi prosessen med å integrere en vektordatabase i RAG-applikasjonen Deres. De har lært:

Hvordan De initialiserer en klient for vektordatabasen.
Den nødvendige datastrukturen (ID, vektor, metadata) for indeksering.
Trinnene for å klargjøre og upserte dokumentdelene og embeddingene deres.
Hvordan De utfører et likhetssøk (spørring) for å hente relevant kontekst.

Med denne kunnskapen er De klare til å koble RAG-applikasjonen Deres til kraftige vektordatabaser som Pinecone, Chroma eller Weaviate!

Gratis å komme i gang

Lær deg LLM-applikasjoner i produksjon (RAG + vektordatabase + hurtigbufring) med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Integrasjon med en vektordatabase» gratis?

Ja – hele teksten i «Integrasjon med en vektordatabase» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av LLM-applikasjoner i produksjon (RAG + vektordatabase + hurtigbufring)-kurset, kan du oppgradere til CoddyKit PRO. Kurset i LLM-applikasjoner i produksjon (RAG + vektordatabase + hurtigbufring) inneholder totalt 4 leksjoner.

Hva lærer jeg i «Integrasjon med en vektordatabase»?

Lær å koble RAG-applikasjonen til en vektordatabase som Pinecone, Weaviate eller Chroma, og utføre indeksering og spørringer. Du øver på LLM-applikasjoner i produksjon (RAG + vektordatabase + hurtigbufring) med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med LLM-applikasjoner i produksjon (RAG + vektordatabase + hurtigbufring)?

Ingen tidligere erfaring er nødvendig. LLM-applikasjoner i produksjon (RAG + vektordatabase + hurtigbufring) på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Integrasjon med en vektordatabase»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne LLM-applikasjoner i produksjon (RAG + vektordatabase + hurtigbufring)-leksjonen?

Ja. Alle LLM-applikasjoner i produksjon (RAG + vektordatabase + hurtigbufring)-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til LLM-applikasjoner i produksjon (RAG + vektordatabase + hurtigbufring)