Lagra och hämta embeddingar
Implementera processen för att generera embeddingar från dokumentdelar och lagra dem i en vektordatabas för senare hämtning.
Lagra och hämta embeddingar är en gratis lektion i LangChain / RAG / vektordatabaser 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 LangChain / RAG / vektordatabaser, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i LangChain / RAG / vektordatabaser innehåller totalt 4 lektioner.
Lagra och hämta embeddings
Välkommen till lektion 3! I den här lektionen knyter vi samman textdelar och vektordatabaser.
Du får lära dig att generera numeriska representationer (embeddings) från dina dokumentdelar och sedan lagra dem effektivt i en vektordatabas för snabb och träffsäker hämtning.
Sammanfattning: delar och embeddings
Innan vi går vidare sammanfattar vi snabbt. Från tidigare lektioner vet du att:
- Dokumentdelar: Stora dokument delas upp i mindre, hanterbara delar för att få plats i LLM:s kontextfönster och förbättra detaljnivån vid hämtning.
- Text-embeddings: Det här är numeriska vektorer som fångar textens semantiska betydelse. Liknande texter har liknande embeddings.
Vårt mål nu är att omvandla dessa delar till embeddings och göra dem sökbara!
Flödet för lagring och hämtning
Här är det typiska arbetsflödet för att göra dina data redo för RAG:
- Läs in och dela upp: Läs in råa dokument och bryt ned dem i delar.
- Skapa embeddings: Omvandla varje textdel till en embedding-vektor med hjälp av en embedding-modell.
- Lagra: Spara dessa embedding-vektorer (tillsammans med de ursprungliga textdelarna och metadata) i en vektordatabas.
- Hämta: När en användare ställer en fråga skapar du en embedding av frågan, söker i vektordatabasen efter liknande embeddings och hämtar de mest relevanta delarna.
Initiera en embedding-modell
Först behöver vi en embedding-modell. LangChain tillhandahåller gränssnitt för många modeller, bland annat från OpenAI och Cohere samt lokala modeller som de från Hugging Face.
I det här exemplet använder vi en lokal Hugging Face-modell för att slippa behöva en API-nyckel. Den här modellen omvandlar text till en vektor med tal.
from langchain_community.embeddings import HuggingFaceEmbeddings
# Initialize a local embedding model
# This might download the model the first time
embeddings_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
print("Embedding model initialized successfully!")Generera embeddings från text
När vår embedding-modell är klar kan vi mata in textdelar i den. Modellen returnerar sedan en lista med tal (vår embedding-vektor) för varje del.
Det är dessa vektorer som vektordatabasen använder för att hitta liknande informationsdelar.
from langchain_community.embeddings import HuggingFaceEmbeddings
embeddings_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
texts_to_embed = [
"The quick brown fox jumps over the lazy dog.",
"A canine named Fido is taking a nap."
]
# Generate embeddings for the texts
vectors = embeddings_model.embed_documents(texts_to_embed)
print(f"Number of vectors generated: {len(vectors)}")
print(f"Dimension of each vector: {len(vectors[0])}")
# print(f"First vector (partial): {vectors[0][:5]}...") # Too long for mobile
Introduktion till vektorlager
Ett vektorlager är en specialiserad databas som är utformad för att effektivt lagra och söka i högdimensionella vektorer. Det är byggt för att snabbt hitta vektorer som ligger ”nära” en viss frågevektor.
Tänk på det som ett supersnabbt index för semantisk betydelse. När du söker letar det inte efter nyckelord, utan efter betydelse.
LangChain stöder många vektorlager, från enkla minnesbaserade som FAISS till robusta molntjänster som Pinecone eller Chroma.
Lagra embeddings med FAISS
Vi använder FAISS, ett minnesbaserat vektorlager, för att demonstrera lagring. Vi tar våra textdelar och deras embeddings och lägger till dem i FAISS. FAISS hanterar indexeringen för snabb sökning.
I en verklig tillämpning skulle du först läsa in delar från dokument, sedan skapa embeddings av dem och till sist lagra dem. Här skapar vi enkla dokument direkt.
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_core.documents import Document
embeddings_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
# Create some example documents (text chunks with optional metadata)
documents = [
Document(page_content="The capital of France is Paris.", metadata={"source": "geo"}),
Document(page_content="Eiffel Tower is a landmark in Paris.", metadata={"source": "tourism"}),
Document(page_content="Python is a popular programming language.", metadata={"source": "tech"}),
Document(page_content="Coding with Python is fun and versatile.", metadata={"source": "tech"})
]
# Create a FAISS vector store from the documents and embeddings model
vectorstore = FAISS.from_documents(documents, embeddings_model)
print("Documents successfully stored in FAISS vector store!")Genomföra en likhetssökning
Nu när våra dokument har fått embeddings och lagrats kan vi fråga vektorlagret för att hitta de dokument som semantiskt liknar vår fråga mest.
Vektorlagret skapar en embedding av din fråga, jämför dess vektor med alla lagrade vektorer och returnerar de översta ”k” (t.ex. de 4 översta) mest liknande dokumenten.
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_core.documents import Document
embeddings_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
documents = [
Document(page_content="The capital of France is Paris.", metadata={"source": "geo"}),
Document(page_content="Eiffel Tower is a landmark in Paris.", metadata={"source": "tourism"}),
Document(page_content="Python is a popular programming language.", metadata={"source": "tech"}),
Document(page_content="Coding with Python is fun and versatile.", metadata={"source": "tech"})
]
vectorstore = FAISS.from_documents(documents, embeddings_model)
query = "What is the main city of France?"
# Perform a similarity search
retrieved_docs = vectorstore.similarity_search(query, k=2)
print(f"Query: '{query}'\n")
print("Top 2 retrieved documents:")
for i, doc in enumerate(retrieved_docs):
print(f"{i+1}. Content: '{doc.page_content}' (Source: {doc.metadata['source']})")Metadata är din vän
Lägg märke till att vi inkluderade metadata med våra dokument i det föregående exemplet. Det är otroligt kraftfullt!
- Filtrering: Du kan filtrera sökningar utifrån metadata (t.ex. söka endast i dokument från en viss författare eller ett visst datum).
- Sammanhang: Metadata hjälper LLM:en att förstå den hämtade delens källa och relevans, vilket förbättrar svarens kvalitet.
- Felsökning: Det blir enklare att spåra var informationen kom ifrån.
Tänk alltid igenom vilken metadata som är användbar att lagra tillsammans med dina textdelar.
Snabb kontroll
Du har lärt dig stegen för att förbereda dina data för ett RAG-system. Vilken är den korrekta ordningsföljden för att lagra och hämta information?
Sammanfattning: lagra och hämta
Bra jobbat! I den här lektionen har du bemästrat de viktiga stegen för att förbereda dina data för ett RAG-system:
- Initiera en embedding-modell för att omvandla text till numeriska vektorer.
- Förstå rollen hos ett vektorlager för effektiv lagring och likhetssökning.
- Implementera processen för att generera embeddings och lagra dem (t.ex. med FAISS).
- Genomföra likhetssökningar för att hämta relevanta dokumentdelar utifrån en fråga.
- Förstå betydelsen av metadata för ett rikare sammanhang och filtrering.
Dessa kunskaper är grundläggande för att bygga effektiva RAG-tillämpningar!
Lär dig LangChain / RAG / vektordatabaser 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 ”Lagra och hämta embeddingar” gratis?
Ja – hela texten till ”Lagra och hämta embeddingar” 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 LangChain / RAG / vektordatabaser, kan Ni uppgradera till CoddyKit PRO. Kursen i LangChain / RAG / vektordatabaser innehåller totalt 4 lektioner.
Vad lär jag mig i ”Lagra och hämta embeddingar”?
Implementera processen för att generera embeddingar från dokumentdelar och lagra dem i en vektordatabas för senare hämtning. Ni övar på LangChain / RAG / vektordatabaser 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 LangChain / RAG / vektordatabaser?
Du behöver inga förkunskaper. Utbildningen i LangChain / RAG / vektordatabaser 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 ”Lagra och hämta embeddingar”?
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 LangChain / RAG / vektordatabaser-lektionen?
Ja. Varje LangChain / RAG / vektordatabaser-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
- Förstå textembeddingar
- Introduktion till vektordatabaser
- Lagra och hämta embeddingar
- Mäta likhet mellan embeddings