LangChain / RAG / Vector DBs · درس

تخزين التضمينات واسترجاعها

طبّق عملية إنشاء التضمينات من أجزاء المستندات وتخزينها في قاعدة بيانات متجهية لاسترجاعها لاحقًا.

تخزين التضمينات واسترجاعها درس مجاني في LangChain / RAG / Vector DBs على CoddyKit. هذا هو الدرس 3 من أصل 4. يمكنك قراءة الدرس كاملاً أدناه مجاناً — ثم تمرن عليه مباشرة في المتصفح باستخدام محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7. هذا الدرس جزء من مسار التعلم في LangChain / RAG / Vector DBs، وتقدمك يتزامن عبر الويب وتطبيق CoddyKit. تتضمن دورة LangChain / RAG / Vector DBs 4 دروس في المجموع.

بعض أجزاء هذا الدرس لم تُترجم بعد وتظهر باللغة الإنجليزية.

Storing & Retrieving Embeddings

Welcome to Lesson 3! In this lesson, we'll connect the dots between text chunks and vector databases.

You'll learn how to generate numerical representations (embeddings) from your document chunks and then store them efficiently in a vector database for quick and accurate retrieval.

Recap: Chunks & Embeddings

Before we dive in, let's quickly recap. From previous lessons, you know:

Document Chunks: Large documents are split into smaller, manageable pieces to fit LLM context windows and improve retrieval granularity.
Text Embeddings: These are numerical vectors that capture the semantic meaning of text. Similar texts have similar embeddings.

Our goal now is to turn those chunks into embeddings and make them searchable!

The Storage & Retrieval Flow

Here's the typical workflow for getting your data ready for RAG:

Load & Split: Ingest raw documents and break them into chunks.
Embed: Convert each text chunk into an embedding vector using an embedding model.
Store: Save these embedding vectors (along with their original text chunks and metadata) in a vector database.
Retrieve: When a user asks a question, embed the query, search the vector database for similar embeddings, and retrieve the most relevant chunks.

Initializing an Embedding Model

First, we need an embedding model. LangChain provides interfaces for many models, including those from OpenAI, Cohere, and local models like those from Hugging Face.

For this example, we'll use a local Hugging Face model to avoid needing an API key. This model turns text into a vector of numbers.

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!")

Generating Embeddings from Text

Once our embedding model is ready, we can feed it text chunks. The model will then output a list of numbers (our embedding vector) for each chunk.

These vectors are what the vector database will use to find similar pieces of information.

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

Introducing Vector Stores

A vector store is a specialized database designed to efficiently store and query high-dimensional vectors. It's built to quickly find vectors that are 'close' to a given query vector.

Think of it as a super-fast index for semantic meaning. When you search, it doesn't look for keywords; it looks for meaning.

LangChain supports many vector stores, from simple in-memory ones like FAISS to robust cloud services like Pinecone or Chroma.

Storing Embeddings with FAISS

Let's use FAISS, an in-memory vector store, to demonstrate storage. We'll take our text chunks and their embeddings and add them to FAISS. FAISS handles the indexing for fast search.

In a real application, you'd load chunks from documents first, then embed them, and finally store them. Here, we'll create simple documents directly.

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!")

Performing a Similarity Search

Now that our documents are embedded and stored, we can query the vector store to find the most semantically similar documents to our question.

The vector store will embed your query, compare its vector to all stored vectors, and return the top 'k' (e.g., top 4) most similar documents.

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 is Your Friend

Notice in the previous example how we included metadata with our documents? This is incredibly powerful!

Filtering: You can filter searches based on metadata (e.g., only search documents from a specific author or date).
Context: Metadata helps the LLM understand the source and relevance of the retrieved chunk, improving answer quality.
Debugging: It's easier to trace where information came from.

Always consider what metadata is useful to store alongside your text chunks.

Quick Check

You've learned about the steps to prepare your data for a RAG system. What is the correct sequence for storing and retrieving information?

Recap: Storing & Retrieving

Great job! In this lesson, you've mastered the critical steps of preparing your data for a RAG system:

Initializing an embedding model to convert text into numerical vectors.
Understanding the role of a vector store for efficient storage and similarity search.
Implementing the process of generating embeddings and storing them (e.g., using FAISS).
Performing similarity searches to retrieve relevant document chunks based on a query.
Recognizing the importance of metadata for richer context and filtering.

These skills are fundamental to building effective RAG applications!

الأسئلة الشائعة

هل درس «تخزين التضمينات واسترجاعها» مجاني؟

نعم — نص درس «تخزين التضمينات واسترجاعها» كامل متاح مجاناً هنا على الويب. لتمرينه بشكل تفاعلي (محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7) وفتح باقي دورة LangChain / RAG / Vector DBs، انتقل إلى CoddyKit PRO. تتضمن دورة LangChain / RAG / Vector DBs 4 دروس في المجموع.

ماذا ستتعلم في «تخزين التضمينات واسترجاعها»؟

طبّق عملية إنشاء التضمينات من أجزاء المستندات وتخزينها في قاعدة بيانات متجهية لاسترجاعها لاحقًا. تتمرن على LangChain / RAG / Vector DBs مع أكواد عملية تشغلها مباشرة في المتصفح، ومدرس ذكاء اصطناعي متاح 24/7 يجيب على أسئلتك أثناء عملك.

هل أحتاج إلى خبرة سابقة لأبدأ LangChain / RAG / Vector DBs؟

لا تُشترط خبرة سابقة. LangChain / RAG / Vector DBs على CoddyKit منظم للمبتدئين حتى المتقدمين، لذا يمكنك البدء من هنا أو من البداية والتقدم بسرعتك الخاصة. هذا هو الدرس 3 من أصل 4.

كم من الوقت يستغرق درس «تخزين التضمينات واسترجاعها»؟

معظم دروس CoddyKit تستغرق حوالي 5–10 دقائق. كل منها موجز وتفاعلي، لذا تحرز تقدماً مستمراً وتستأنف من حيث توقفت عبر الويب والتطبيق.

هل يمكنني كتابة وتشغيل أكواد في درس LangChain / RAG / Vector DBs هذا؟

نعم. كل درس في LangChain / RAG / Vector DBs يتضمن محرر أكواد مدمج، لذا تكتب وتشغل أكواداً حقيقية مباشرة في متصفحك وتحصل على تعليقات فورية من الذكاء الاصطناعي — بدون إعداد محلي.

جميع الدروس في هذه الدورة

← العودة إلى LangChain / RAG / Vector DBs