Open-source embedding models in LangChain - Mini Project: Build & Apply

Using Open-source Embedding Models with Langchain

📖 Scenario: You want to build a simple text search tool using open-source embedding models with Langchain. This tool will convert text into vectors that computers can understand and compare.

🎯 Goal: Build a small Langchain program that loads an open-source embedding model, creates embeddings for a list of texts, and stores them in a vector store.

📋 What You'll Learn

Create a list of texts to embed

Set up the embedding model configuration

Generate embeddings for the texts using the model

Store the embeddings in a vector store

💡 Why This Matters

🌍 Real World

Embedding models help computers understand text by turning words into numbers. This is useful for search engines, chatbots, and recommendation systems.

💼 Career

Knowing how to use open-source embedding models with Langchain is valuable for roles in AI development, data science, and software engineering focused on natural language processing.

1

Create a list of texts to embed

Create a Python list called documents with these exact strings: 'Hello world', 'Langchain is great', and 'Open-source embeddings'.

LangChain

# Create a list called documents with the specified texts
# Your code here

Hint

Use square brackets [] to create a list and separate strings with commas.

2

Set up the embedding model configuration

Import HuggingFaceEmbeddings from langchain.embeddings and create a variable called embedding_model that initializes HuggingFaceEmbeddings with the model name 'sentence-transformers/all-MiniLM-L6-v2'.

LangChain

documents = ['Hello world', 'Langchain is great', 'Open-source embeddings']
# Import HuggingFaceEmbeddings and create embedding_model with the specified model name
# Your code here

Hint

Use the exact model name string and import statement as shown.

3

Generate embeddings for the texts using the model

Create a variable called embeddings and assign it the result of calling embedding_model.embed_documents(documents) to generate embeddings for the documents list.

LangChain

from langchain.embeddings import HuggingFaceEmbeddings

documents = ['Hello world', 'Langchain is great', 'Open-source embeddings']

embedding_model = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')
# Generate embeddings for documents and store in embeddings
# Your code here

Hint

Call embed_documents on embedding_model with documents as argument.

4

Store the embeddings in a vector store

Import FAISS from langchain.vectorstores and create a variable called vector_store by calling FAISS.from_texts(documents, embedding_model) to store the documents and their embeddings.

LangChain

from langchain.embeddings import HuggingFaceEmbeddings

documents = ['Hello world', 'Langchain is great', 'Open-source embeddings']

embedding_model = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')

embeddings = embedding_model.embed_documents(documents)
# Import FAISS and create vector_store = FAISS.from_texts(documents, embedding_model)
# Your code here

Hint

Use FAISS.from_texts(documents, embedding_model) to create the vector store.

Practice

1. What is the main purpose of open-source embedding models in Langchain?

easy

A. To generate images from text

B. To create user interfaces for apps

C. To store large databases efficiently

D. To convert text into numbers that computers can understand

Solution

1. Step 1: Understand embedding models

   Embedding models convert text into numerical vectors so computers can process meaning.

2. Step 2: Identify Langchain's role

   Langchain uses these models to help build language apps that understand text better.

3. Final Answer:

   To convert text into numbers that computers can understand -> Option D

4. Quick Check:

   Embedding models = convert text to numbers [OK]

Hint: Remember embeddings turn words into numbers [OK]

Common Mistakes:

• Confusing embeddings with UI design
• Thinking embeddings store data
• Mixing embeddings with image generation

2. Which code snippet correctly creates an embedding model instance using Langchain's open-source model?

easy

A. embedding = create_embedding('all-MiniLM-L6-v2')

B. embedding = OpenAIEmbeddings()

C. embedding = HuggingFaceEmbeddings(model_name='all-MiniLM-L6-v2')

D. embedding = EmbeddingModel('OpenAI')

Solution

1. Step 1: Recall Langchain embedding syntax

   Langchain uses classes like HuggingFaceEmbeddings with a model_name parameter for open-source models.

2. Step 2: Check each option

   embedding = HuggingFaceEmbeddings(model_name='all-MiniLM-L6-v2') matches the correct syntax for creating a HuggingFace embedding instance.

3. Final Answer:

   embedding = HuggingFaceEmbeddings(model_name='all-MiniLM-L6-v2') -> Option C

4. Quick Check:

   Correct class and parameter = embedding = HuggingFaceEmbeddings(model_name='all-MiniLM-L6-v2') [OK]

Hint: Look for class name and model_name parameter [OK]

Common Mistakes:

• Using OpenAIEmbeddings for open-source models
• Calling a non-existent create_embedding function
• Passing wrong arguments to constructors

3. What will be the output type when you run this code snippet in Langchain?

from langchain.embeddings import HuggingFaceEmbeddings
embedding = HuggingFaceEmbeddings(model_name='all-MiniLM-L6-v2')
vector = embedding.embed_query('Hello world')

medium

A. A dictionary with word counts

B. A list of numbers representing the text

C. A string with the original text

D. An error because embed_query is invalid

Solution

1. Step 1: Understand embed_query method

   The embed_query method converts input text into a vector, which is a list of numbers.

2. Step 2: Check output type

   The variable 'vector' will hold a list (array) of floats representing the text embedding.

3. Final Answer:

   A list of numbers representing the text -> Option B

4. Quick Check:

   embed_query output = list of numbers [OK]

Hint: embed_query returns numeric vectors, not strings [OK]

Common Mistakes:

• Expecting a string instead of numbers
• Thinking output is a dictionary
• Assuming embed_query method does not exist

4. Identify the error in this Langchain code using an open-source embedding model:

from langchain.embeddings import HuggingFaceEmbeddings
embedding = HuggingFaceEmbeddings('all-MiniLM-L6-v2')
vector = embedding.embed_query('Test')

medium

A. Missing model_name keyword argument in HuggingFaceEmbeddings constructor

B. embed_query method does not exist in HuggingFaceEmbeddings

C. The import statement is incorrect

D. The string 'Test' should be a list

Solution

1. Step 1: Check constructor usage

   HuggingFaceEmbeddings requires model_name as a keyword argument, not a positional argument.

2. Step 2: Verify method and import

   embed_query exists and import is correct; input can be a string.

3. Final Answer:

   Missing model_name keyword argument in HuggingFaceEmbeddings constructor -> Option A

4. Quick Check:

   Constructor needs model_name=... [OK]

Hint: Use model_name= when creating HuggingFaceEmbeddings [OK]

Common Mistakes:

• Passing model name as positional argument
• Thinking embed_query is missing
• Changing input type unnecessarily

5. You want to build a semantic search using Langchain with an open-source embedding model. Which approach correctly combines embeddings and a vector store?

hard

A. Create embeddings with HuggingFaceEmbeddings, then store vectors in FAISS for fast similarity search

B. Use OpenAIEmbeddings and store raw text in a SQL database

C. Generate embeddings with HuggingFaceEmbeddings and store them as plain text files

D. Use HuggingFaceEmbeddings without any vector store for search

Solution

1. Step 1: Understand semantic search components

   Semantic search needs embeddings to represent text and a vector store to find similar vectors quickly.

2. Step 2: Match correct tools

   HuggingFaceEmbeddings creates vectors; FAISS is a popular vector store for fast similarity search.

3. Step 3: Evaluate other options

   OpenAIEmbeddings is not open-source; storing raw text or plain files won't enable vector search; no vector store means no fast search.

4. Final Answer:

   Create embeddings with HuggingFaceEmbeddings, then store vectors in FAISS for fast similarity search -> Option A

5. Quick Check:

   Embedding + vector store = semantic search [OK]

Hint: Combine embeddings with vector store like FAISS [OK]

Common Mistakes:

• Using non-open-source embeddings
• Storing embeddings as plain text
• Skipping vector store for search