LangChain vs direct API calls - Hands-On Comparison

LangChain vs Direct API Calls

📖 Scenario: You want to build a simple program that asks a question to an AI language model. You will first set up the question, then configure the API key, then write code to call the AI model directly using the OpenAI API, and finally write code to call the AI model using LangChain. This will help you see the difference between using LangChain and direct API calls.

🎯 Goal: Build a Python script that sends a question to an AI language model in two ways: first by calling the OpenAI API directly, and second by using LangChain's OpenAI wrapper. You will compare how the code looks and works.

📋 What You'll Learn

Create a variable called question with the exact string: 'What is the capital of France?'

Create a variable called api_key with the exact string: 'test-api-key'

Write code to call the OpenAI API directly using openai.ChatCompletion.create with the question and api_key

Write code to call the OpenAI model using LangChain's ChatOpenAI class with the question and api_key

💡 Why This Matters

🌍 Real World

Developers often need to interact with AI models. They can call APIs directly or use frameworks like LangChain to simplify and organize their code.

💼 Career

Understanding both direct API calls and using frameworks like LangChain is valuable for AI developers, data scientists, and software engineers working with language models.

1

DATA SETUP: Create the question variable

Create a variable called question and set it to the string 'What is the capital of France?'

LangChain

# Create the question variable
# Your code here

Hint

Use a simple assignment like question = 'What is the capital of France?'

2

CONFIGURATION: Add the API key variable

Create a variable called api_key and set it to the string 'test-api-key'

LangChain

question = 'What is the capital of France?'
# Create the api_key variable
# Your code here

Hint

Use a simple assignment like api_key = 'test-api-key'

3

CORE LOGIC: Call OpenAI API directly

Write code to call the OpenAI API directly using openai.ChatCompletion.create with the question and api_key. Assign the response to a variable called direct_response. Use the model 'gpt-4' and pass the message as [{'role': 'user', 'content': question}]. Set the API key using openai.api_key = api_key.

LangChain

question = 'What is the capital of France?'
api_key = 'test-api-key'
# Call OpenAI API directly and assign to direct_response
# Your code here

Hint

Remember to import openai and set openai.api_key = api_key before calling openai.ChatCompletion.create.

4

COMPLETION: Call OpenAI model using LangChain

Write code to call the OpenAI model using LangChain's ChatOpenAI class. Import ChatOpenAI from langchain.chat_models. Create an instance called llm with model_name='gpt-4' and openai_api_key=api_key. Then call llm(question) with the question and assign the result to langchain_response.

LangChain

import openai

question = 'What is the capital of France?'
api_key = 'test-api-key'

openai.api_key = api_key
direct_response = openai.ChatCompletion.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': question}]
)

# Import ChatOpenAI from langchain.chat_models and call the model
# Your code here

Hint

Import ChatOpenAI from langchain.chat_models. Create llm with the API key and model name. Use llm(question) to get the response.

Practice

1. What is the main advantage of using LangChain over direct API calls?

easy

A. LangChain simplifies building complex language model applications by wrapping API calls.

B. LangChain requires more manual setup than direct API calls.

C. LangChain offers less control over API parameters than direct calls.

D. LangChain is only useful for simple scripts without complex logic.

Solution

1. Step 1: Understand LangChain's purpose

   LangChain is designed to wrap API calls to make using language models easier and more powerful.

2. Step 2: Compare with direct API calls

   Direct API calls require manual setup and offer full control but are more complex to manage.

3. Final Answer:

   LangChain simplifies building complex language model applications by wrapping API calls. -> Option A

4. Quick Check:

   LangChain simplifies API use = C [OK]

Hint: LangChain wraps APIs to simplify complex tasks [OK]

Common Mistakes:

• Thinking LangChain requires more manual setup
• Believing LangChain offers less control
• Assuming LangChain is only for simple scripts

2. Which of the following is the correct way to create a LangChain LLM instance in Python?

easy

A. llm = OpenAI(model_name="gpt-4")

B. llm = OpenAI('gpt-4')

C. llm = OpenAI.create('gpt-4')

D. llm = OpenAI.new(model='gpt-4')

Solution

1. Step 1: Recall LangChain LLM instantiation syntax

   LangChain uses keyword arguments to specify model parameters, e.g., model_name="gpt-4".

2. Step 2: Check each option's syntax

   llm = OpenAI(model_name="gpt-4") uses correct keyword argument syntax; others use invalid or nonexistent methods.

3. Final Answer:

   llm = OpenAI(model_name="gpt-4") -> Option A

4. Quick Check:

   Correct LangChain LLM syntax = D [OK]

Hint: Use keyword args like model_name="gpt-4" to create LLM [OK]

Common Mistakes:

• Using positional arguments instead of keywords
• Calling nonexistent methods like create() or new()
• Missing quotes around model name

3. Given this code using LangChain:

from langchain.llms import OpenAI
llm = OpenAI(model_name="gpt-3.5-turbo")
response = llm("Hello, how are you?")
print(response)

What will this code do compared to making a direct API call?

medium

A. It sends no request because LangChain requires explicit API calls.

B. It will raise a syntax error because llm is not callable.

C. It automatically handles API details and returns the model's text response.

D. It returns raw JSON instead of text.

Solution

1. Step 1: Understand LangChain LLM call behavior

   Calling llm(...) sends the prompt to the API and returns the text response automatically.

2. Step 2: Compare with direct API calls

   Direct calls require manual request setup and parsing; LangChain simplifies this.

3. Final Answer:

   It automatically handles API details and returns the model's text response. -> Option C

4. Quick Check:

   LangChain call returns text response = A [OK]

Hint: LangChain llm() returns text response directly [OK]

Common Mistakes:

• Thinking llm object is not callable
• Assuming LangChain needs manual API calls
• Expecting raw JSON instead of text

4. You wrote this direct API call code but get an error:

import openai
response = openai.ChatCompletion.create(
  model="gpt-4",
  messages=[{"role": "user", "content": "Hello"}]
)
print(response.choices[0].message.content)

What is the likely cause of the error?

medium

A. The messages parameter should be a string, not a list.

B. Missing openai.api_key setup before calling the API.

C. The model name "gpt-4" is invalid in direct API calls.

D. The print statement syntax is incorrect.

Solution

1. Step 1: Check API call requirements

   Direct API calls require setting openai.api_key before usage to authenticate requests.

2. Step 2: Validate other parameters and syntax

   Messages as list is correct, model name is valid, and print syntax is correct.

3. Final Answer:

   Missing openai.api_key setup before calling the API. -> Option B

4. Quick Check:

   API key missing causes error = B [OK]

Hint: Always set openai.api_key before direct API calls [OK]

Common Mistakes:

• Passing messages as string instead of list
• Using invalid model names
• Incorrect print syntax

5. You want to build a chatbot app that uses multiple language models and chains prompts together. Which approach is best and why?

hard

A. Use LangChain only if you want to avoid API keys.

B. Use direct API calls because they are simpler for chaining multiple models.

C. Use direct API calls because LangChain cannot handle multiple models.

D. Use LangChain because it provides tools to manage chains and multiple models easily.

Solution

1. Step 1: Identify requirements for chaining and multiple models

   Building a chatbot with multiple models and prompt chains needs orchestration tools.

2. Step 2: Compare LangChain and direct API calls for this use case

   LangChain offers built-in support for chains and managing multiple models, simplifying app building.

3. Step 3: Evaluate incorrect options

   Direct API calls require manual chaining logic; LangChain does not avoid API keys.

4. Final Answer:

   Use LangChain because it provides tools to manage chains and multiple models easily. -> Option D

5. Quick Check:

   LangChain best for chaining models = A [OK]

Hint: LangChain simplifies chaining and multi-model apps [OK]

Common Mistakes:

• Thinking direct calls are simpler for chaining
• Believing LangChain can't handle multiple models
• Assuming LangChain removes need for API keys