OpenAI embeddings in LangChain - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this LangChain OpenAI embeddings code?

Consider this Python code using LangChain's OpenAIEmbeddings to embed a list of texts. What is the type of the variable embeddings after running this code?

LangChain

from langchain.embeddings import OpenAIEmbeddings
texts = ["Hello world", "LangChain is cool"]
embedder = OpenAIEmbeddings()
embeddings = [embedder.embed_query(text) for text in texts]

A A single list of floats representing the combined embedding of all texts

B A list of lists of floats, each inner list is an embedding vector for a text

C A dictionary mapping each text to its embedding vector

D A string containing the concatenated embeddings as text

💡 Hint

Think about what embed_query returns for each text and how the list comprehension works.

The embed_query method returns a list of floats representing the embedding vector for a single text. Using a list comprehension over multiple texts produces a list of these lists.

📝 Syntax

intermediate

Which option correctly initializes OpenAIEmbeddings with a custom model name?

You want to create an OpenAIEmbeddings instance using the model named "text-embedding-3-large". Which code snippet is correct?

A embedder = OpenAIEmbeddings(model_name="text-embedding-3-large")

B embedder = OpenAIEmbeddings(model="text-embedding-3-large")

C embedder = OpenAIEmbeddings(name="text-embedding-3-large")

D embedder = OpenAIEmbeddings(modelName="text-embedding-3-large")

💡 Hint

Check the official parameter name for specifying the model in OpenAIEmbeddings.

The correct parameter to specify the model name in OpenAIEmbeddings is model_name. Other parameter names will cause errors.

❓ state_output

advanced

What is the length of the embedding vector produced by OpenAIEmbeddings by default?

Using the default OpenAIEmbeddings without specifying a model, what is the typical length of the embedding vector returned by embed_query?

LangChain

from langchain.embeddings import OpenAIEmbeddings
embedder = OpenAIEmbeddings()
vector = embedder.embed_query("test")
length = len(vector)

A 512

B 2048

C 1024

D 1536

💡 Hint

The default OpenAI embedding model returns vectors of a fixed size used widely in practice.

The default OpenAI embedding model returns vectors of length 1536 floats.

🔧 Debug

advanced

Why does this code raise a TypeError?

This code snippet raises a TypeError. What is the cause?

LangChain

from langchain.embeddings import OpenAIEmbeddings
embedder = OpenAIEmbeddings()
result = embedder.embed_query(12345)

A embed_query expects a string input, but an integer was given

B OpenAIEmbeddings must be initialized with an API key before use

C embed_query returns None when input is not a string

D The import statement is incorrect and causes the error

💡 Hint

Check the input type required by embed_query.

The embed_query method requires a string input. Passing an integer causes a TypeError.

🧠 Conceptual

expert

Which statement best describes how OpenAIEmbeddings integrates with LangChain's document search?

How does OpenAIEmbeddings typically work within LangChain to enable semantic search over documents?

A It generates summaries of documents to speed up search

B It directly indexes documents as text strings for keyword matching

C It converts documents and queries into vectors so that similarity can be computed to find relevant documents

D It replaces the need for any vector database by storing embeddings in memory

💡 Hint

Think about what embeddings represent and how they help find related content.

OpenAIEmbeddings converts text into numeric vectors. LangChain uses these vectors to compare similarity between queries and documents, enabling semantic search.

Practice

1. What is the main purpose of OpenAI embeddings in Langchain?

easy

A. To convert text into numerical vectors that represent meaning

B. To generate images from text descriptions

C. To translate text from one language to another

D. To create user interfaces automatically

Solution

1. Step 1: Understand what embeddings do

   Embeddings turn text into lists of numbers that capture the meaning of the text.

2. Step 2: Identify the purpose in Langchain

   Langchain uses embeddings to help computers find similar or related texts easily by comparing these number lists.

3. Final Answer:

   To convert text into numerical vectors that represent meaning -> Option A

4. Quick Check:

   Embeddings = numerical meaning vectors [OK]

Hint: Embeddings = text to numbers showing meaning [OK]

Common Mistakes:

• Confusing embeddings with image generation
• Thinking embeddings translate languages
• Assuming embeddings create UI elements

2. Which of the following is the correct way to create OpenAI embeddings using Langchain in Python?

easy

A. import OpenAI from langchain
embeddings = OpenAI.create_embeddings()

B. import langchain
embeddings = langchain.OpenAIEmbeddings()

C. from langchain import embeddings
embeddings = embeddings.OpenAI()

D. from langchain.embeddings import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()

Solution

1. Step 1: Check the import statement

   The correct import is from langchain.embeddings import OpenAIEmbeddings.

2. Step 2: Check the instantiation

   Creating embeddings is done by calling OpenAIEmbeddings() with parentheses.

3. Final Answer:

   from langchain.embeddings import OpenAIEmbeddings\nembeddings = OpenAIEmbeddings() -> Option D

4. Quick Check:

   Correct import and instantiation syntax [OK]

Hint: Import from langchain.embeddings, then call OpenAIEmbeddings() [OK]

Common Mistakes:

• Wrong import path or module
• Missing parentheses when creating embeddings
• Using incorrect method names

3. Given the code snippet:

from langchain.embeddings import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
vector = embeddings.embed_query('Hello world')

What is the type of vector?

medium

A. A dictionary with text keys and values

B. A string containing the original text

C. A list of numbers representing the text meaning

D. An integer representing text length

Solution

1. Step 1: Understand embed_query output

   The embed_query method returns a list of numbers (a vector) representing the meaning of the input text.

2. Step 2: Identify the type of vector

   Since it encodes meaning, the vector is a list of floats or numbers, not a string or dictionary.

3. Final Answer:

   A list of numbers representing the text meaning -> Option C

4. Quick Check:

   embed_query output = number list [OK]

Hint: embed_query returns a number list vector [OK]

Common Mistakes:

• Expecting a string instead of numbers
• Thinking it returns a dictionary
• Assuming it returns text length as integer

4. What is wrong with this code snippet for creating embeddings?

from langchain.embeddings import OpenAIEmbeddings
embeddings = OpenAIEmbeddings
vector = embeddings.embed_query('Test')

medium

A. embed_query method does not exist

B. Missing parentheses when creating OpenAIEmbeddings instance

C. Incorrect import statement

D. The input text must be a list, not a string

Solution

1. Step 1: Check how embeddings instance is created

   The code assigns OpenAIEmbeddings without parentheses, so embeddings is a class, not an instance.

2. Step 2: Understand the impact on embed_query call

   Calling embed_query on the class (not instance) will cause an error because methods need an instance.

3. Final Answer:

   Missing parentheses when creating OpenAIEmbeddings instance -> Option B

4. Quick Check:

   Instantiate with () to call methods [OK]

Hint: Always add () to create instance before method calls [OK]

Common Mistakes:

• Forgetting parentheses when creating instances
• Assuming methods work on classes directly
• Misreading import statements

5. You want to find the most similar text from a list using OpenAI embeddings in Langchain. Which approach correctly uses embeddings to compare similarity?

hard

A. Create embeddings for all texts, then compute cosine similarity between vectors

B. Compare texts directly as strings using == operator

C. Use embed_query only on the first text and compare lengths

D. Generate embeddings but do not compare vectors

Solution

1. Step 1: Understand how similarity is found with embeddings

   Embeddings convert texts into vectors; similarity is measured by comparing these vectors, often with cosine similarity.

2. Step 2: Identify correct approach to find most similar text

   Create embeddings for all texts, then compute similarity scores between vectors to find the closest match.

3. Final Answer:

   Create embeddings for all texts, then compute cosine similarity between vectors -> Option A

4. Quick Check:

   Similarity = compare embedding vectors [OK]

Hint: Compare vector embeddings with cosine similarity [OK]

Common Mistakes:

• Comparing raw strings instead of vectors
• Using embed_query on only one text
• Not comparing embeddings at all