Integrera med en vektordatabas
Lär er att ansluta er RAG-applikation till en vektordatabas som Pinecone, Weaviate eller Chroma samt utföra indexering och sökningar.
Integrera med en vektordatabas är en gratis lektion i LLM-applikationer i produktion (RAG + vektordatabaser + cachning) på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för LLM-applikationer i produktion (RAG + vektordatabaser + cachning), och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i LLM-applikationer i produktion (RAG + vektordatabaser + cachning) innehåller totalt 4 lektioner.
Koppla samman RAG och vektordatabaser
Välkommen till den sista lektionen i kursen ”Fördjupning i vektordatabaser”! Du har lärt dig varför vektordatabaser är viktiga för RAG-system och vad vektorembeddingar är.
Nu knyter vi ihop allt. Den här lektionen fokuserar på de praktiska stegen för att integrera en vektordatabas i din RAG-applikation.
Vi går igenom:
- Att ansluta till en klient för vektordatabasen.
- Att förbereda dina data för lagring.
- Att indexera (lägga till) dina data.
- Att ställa frågor (söka) efter relevant information.
Vektordatabaser i RAG: snabb repetition
Innan vi går in på integrationen repeterar vi kort vektordatabasernas roll i RAG.
De är specialiserade databaser som är utformade för att lagra och effektivt söka i vektorembeddingar. Dessa embeddingar är numeriska representationer av text, bilder eller andra data och fångar deras semantiska betydelse.
När en användare ställer en fråga omvandlar vi den till en embedding, söker i vektordatabasen efter liknande dokumentembeddingar och hämtar de mest relevanta informationsdelarna. Denna kontext skickas sedan till LLM:en.
Välja ett klientbibliotek
För att interagera med en vektordatabas använder du dess officiella klientbibliotek. Dessa bibliotek tillhandahåller metoder för att ansluta, lägga till data, skicka frågor och hantera ditt index.
Populära alternativ är:
- Pinecone Client: För Pinecones molnbaserade vektordatabas.
- ChromaDB Client: För Chroma, en vektordatabas med öppen källkod som ofta används lokalt eller med egen drift.
- Weaviate Client: För Weaviate, ytterligare en populär molnbaserad vektordatabas med öppen källkod.
Varje klient följer ungefär samma mönster för anslutning och åtgärder.
Konfigurera en anslutning
Det första steget är alltid att upprätta en anslutning till din vektordatabas. Det innebär vanligtvis att ett klientobjekt initieras med din API-nyckel, miljöinformation eller värdadress.
Som demonstration använder vi klassen SimpleVectorDB, som förenklar och efterliknar verkliga operationer i vektordatabaser. Kör exemplet för att se hur en klient kan initieras.
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);
}
}Förstå datastrukturen
När du lägger till data i en vektordatabas förväntar den sig vanligtvis tre huvudkomponenter för varje post:
- ID: En unik identifierare för din dokumentdel (till exempel ”doc123-chunk4”).
- Vektor: Den numeriska embeddingen (en lista med flyttal) för din dokumentdel.
- Metadata: Valfria men mycket användbara nyckel-värde-par (till exempel källdokument, sidnummer och författare) som ger ytterligare kontext och möjliggör filtrering vid frågor.
Denna struktur hjälper databasen att hantera och hämta din information effektivt.
Förbereda data för indexering
Innan du kan indexera data måste du förbereda den. Det innebär att:
- Läsa in data: Hämta råtext från olika källor (PDF-filer, webbsidor och databaser).
- Dela upp i delar: Bryta ned långa dokument i mindre, semantiskt meningsfulla delar.
- Skapa embeddingar: Omvandla varje textdel till motsvarande vektorembedding med hjälp av en embeddingmodell.
I den här lektionen antar vi att du redan har dina textdelar och deras embeddingar redo för indexering. Fokus ligger här på interaktionen med själva vektordatabasen.
Indexera dokument (upsert)
Processen att lägga till eller uppdatera vektorer och deras tillhörande metadata i en vektordatabas kallas ofta upsert. Det fungerar som en insättning om ID:t är nytt och som en uppdatering om ID:t redan finns.
Vi utökar vår SimpleVectorDB med en upsert-metod och lägger till exempeldata. Observera att varje post har ett ID, en vektor och 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öra en likhetssökning
När dina data har indexerats kan du utföra frågor. En fråga innebär vanligtvis att:
- Användarens fråga omvandlas till en frågeembedding.
- Denna frågeembedding skickas till vektordatabasen.
- Databasen hittar de k mest lika vektorerna (dokumentdelarna) baserat på deras embeddingar.
- Den returnerar dessa dokumentdelar tillsammans med tillhörande metadata.
Detta är kärnan i hur RAG hämtar relevant kontext!
Kodexempel: Skicka en fråga
Vi lägger till en query-metod i vår SimpleVectorDB och simulerar en sökning. För enkelhetens skull returnerar vår simulerade fråga bara den mest ”lika” posten baserat på en mycket enkel matchningslogik (i en riktig databas är detta en komplex likhetsalgoritm).
Föreställ dig att en användare ställer en fråga och att dess embedding är 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"));
}
}
}Hantera frågeresultat
Resultaten från en fråga till en vektordatabas är vanligtvis en lista med dokumentdelar, rangordnade efter likhet med frågan. Varje resultat innehåller vanligtvis:
- Det ursprungliga ID:t för delen.
- Textinnehållet (om det lagras i metadata eller hämtas separat med hjälp av ID:t).
- Metadata som hör till delen.
- Ett likhetspoäng eller ett avståndsmått.
Din RAG-applikation tar sedan de översta k hämtade delarna, formaterar dem och skickar dem som kontext till Large Language Model för att generera ett välgrundat svar.
Snabbtest: Integrera en vektordatabas
Du har lärt dig de viktigaste stegen för att integrera en vektordatabas. Vilken av följande är den korrekta ordningen på åtgärder när nya textdata läggs till i ett RAG-systems vektordatabas?
Repetition: Integrera vektordatabaser
Bra jobbat! I den här lektionen har vi klargjort hur en vektordatabas integreras i din RAG-applikation. Du har lärt dig:
- Hur man initierar en klient för en vektordatabas.
- Den nödvändiga datastrukturen (ID, vektor och metadata) för indexering.
- Stegen för att förbereda och göra upsert av dina dokumentdelar och deras embeddingar.
- Hur man utför en likhetssökning (fråga) för att hämta relevant kontext.
Med denna kunskap är du redo att ansluta din RAG-applikation till kraftfulla vektordatabaser som Pinecone, Chroma eller Weaviate!
Lär dig LLM-applikationer i produktion (RAG + vektordatabaser + cachning) med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Integrera med en vektordatabas” gratis?
Ja – hela texten till ”Integrera med en vektordatabas” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i LLM-applikationer i produktion (RAG + vektordatabaser + cachning), kan Ni uppgradera till CoddyKit PRO. Kursen i LLM-applikationer i produktion (RAG + vektordatabaser + cachning) innehåller totalt 4 lektioner.
Vad lär jag mig i ”Integrera med en vektordatabas”?
Lär er att ansluta er RAG-applikation till en vektordatabas som Pinecone, Weaviate eller Chroma samt utföra indexering och sökningar. Ni övar på LLM-applikationer i produktion (RAG + vektordatabaser + cachning) med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig LLM-applikationer i produktion (RAG + vektordatabaser + cachning)?
Du behöver inga förkunskaper. Utbildningen i LLM-applikationer i produktion (RAG + vektordatabaser + cachning) på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Integrera med en vektordatabas”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här LLM-applikationer i produktion (RAG + vektordatabaser + cachning)-lektionen?
Ja. Varje LLM-applikationer i produktion (RAG + vektordatabaser + cachning)-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Varför vektordatabaser behövs
- Vektorinbäddningar och likhetssökning
- Integrera med en vektordatabas
- Indexering, filtrering och hybridsökning