LangChain agents in Prompt Engineering / GenAI - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding LangChain Agent Types

Which LangChain agent type is best suited for tasks that require calling multiple tools in a sequence based on user input?

A Agent that dynamically selects and chains multiple tools based on input.

B Conversational agent designed for chat-based interactions without tool usage.

C Agent with memory that stores past interactions but does not use tools.

D Zero-shot agent that uses a single tool without prior examples.

💡 Hint

Think about which agent can decide which tools to use and in what order.

LangChain agents that dynamically select and chain multiple tools are designed to handle complex tasks by calling different tools in sequence based on user input.

❓ Predict Output

intermediate

Output of LangChain Agent Tool Call

What will be the output of this LangChain agent code snippet when the input is 'Translate hello to French'?

Prompt Engineering / GenAI

from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI

def translate(text):
    translations = {'hello': 'bonjour'}
    return translations.get(text.lower(), 'unknown')

tools = [Tool(name='translator', func=translate, description='Translate English to French')]
llm = OpenAI(temperature=0)
agent = initialize_agent(tools, llm, agent='zero-shot-react-description', verbose=False)

output = agent.run('Translate hello to French')
print(output)

A bonjour

B Translate hello to French

C Error: Tool function not found

D unknown

💡 Hint

Check how the translate function maps 'hello' to French.

The translate function returns 'bonjour' for 'hello'. The agent calls this tool correctly, so the output is 'bonjour'.

❓ Hyperparameter

advanced

Choosing Temperature for LangChain Agent LLM

You want your LangChain agent to give very precise and consistent answers without creativity. Which temperature setting for the underlying LLM is best?

A Temperature = -1.0 to disable randomness.

B Temperature = 0.0 for deterministic output.

C Temperature = 0.7 for balanced creativity and accuracy.

D Temperature = 1.0 for maximum creativity.

💡 Hint

Lower temperature means less randomness.

Setting temperature to 0.0 makes the LLM output deterministic and precise, ideal for consistent agent responses.

❓ Metrics

advanced

Evaluating LangChain Agent Performance

Which metric is most appropriate to evaluate a LangChain agent's ability to correctly use tools and provide accurate answers?

A Perplexity of the underlying language model.

B BLEU score measuring text similarity to reference answers.

C Mean Squared Error between predicted and true values.

D Accuracy of tool usage and final answer correctness.

💡 Hint

Think about what matters for an agent using tools to answer questions.

Accuracy of tool usage and final answer correctness directly measures if the agent used the right tools and gave correct answers.

🔧 Debug

expert

Debugging LangChain Agent Tool Integration

Given this LangChain agent code, what is the cause of the error when running the agent?

Prompt Engineering / GenAI

from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI

def calculator(input):
    return eval(input)

tools = [Tool(name='calc', func=calculator, description='Performs calculations')]
llm = OpenAI(temperature=0)
agent = initialize_agent(tools, llm, agent='zero-shot-react-description', verbose=False)

result = agent.run('Calculate 2 + 2')
print(result)

A The tool name 'calc' is not recognized by the agent causing a lookup error.

B The agent cannot parse 'Calculate 2 + 2' because it expects 'calc 2 + 2'.

C The OpenAI LLM is not initialized with an API key, causing authentication failure.

D The 'calculator' function uses eval which is unsafe and blocked by LangChain.

💡 Hint

Check if the LLM initialization is complete and authorized.

Without a valid API key, the OpenAI LLM cannot run, causing the agent to fail.

Practice

1. What is the main purpose of a LangChain agent in AI applications?

easy

A. To combine language models with tools for flexible decision-making

B. To store large datasets for training language models

C. To replace language models with rule-based systems

D. To visualize data using charts and graphs

Solution

1. Step 1: Understand LangChain agent's role

   LangChain agents connect language models with external tools to perform tasks flexibly.

2. Step 2: Compare options

   Only To combine language models with tools for flexible decision-making describes this combination and flexibility; others describe unrelated functions.

3. Final Answer:

   To combine language models with tools for flexible decision-making -> Option A

4. Quick Check:

   LangChain agent purpose = combine models + tools [OK]

Hint: Agents link models and tools to act smartly [OK]

Common Mistakes:

• Thinking agents only store data
• Confusing agents with visualization tools
• Believing agents replace language models

2. Which of the following is the correct way to initialize a LangChain agent with a language model named llm and tools list tools?

easy

A. agent = initialize_agent(llm, tools)

B. agent = Agent(llm, tools)

C. agent = initialize_agent(tools, llm, agent_type='zero-shot')

D. agent = initialize_agent(tools, llm)

Solution

1. Step 1: Recall LangChain agent initialization syntax

   The correct function is initialize_agent with parameters: tools, llm, and agent_type.

2. Step 2: Identify correct parameter order and required arguments

   agent = initialize_agent(tools, llm, agent_type='zero-shot') correctly passes tools first, then llm, and specifies agent_type, which is required.

3. Final Answer:

   agent = initialize_agent(tools, llm, agent_type='zero-shot') -> Option C

4. Quick Check:

   Correct init syntax = tools, llm, agent_type [OK]

Hint: Remember: tools first, then llm, plus agent_type [OK]

Common Mistakes:

• Swapping llm and tools order
• Omitting agent_type parameter
• Using wrong class name instead of initialize_agent

3. Given the code snippet:

from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI

tools = [Tool(name='Search', func=lambda x: 'Found info about ' + x)]
llm = OpenAI(temperature=0)
agent = initialize_agent(tools, llm, agent_type='zero-shot')

response = agent.run('Python programming')

What will response most likely contain?

medium

A. Found info about Python programming

B. Python programming is a programming language

C. Error: missing tool function

D. Empty string

Solution

1. Step 1: Analyze tool function

   The tool named 'Search' returns 'Found info about ' plus the input string.

2. Step 2: Understand agent run behavior

   The agent uses the tool to answer the query 'Python programming', so it calls the tool function.

3. Final Answer:

   Found info about Python programming -> Option A

4. Quick Check:

   Agent output = tool response + input [OK]

Hint: Agent runs tool function on input text [OK]

Common Mistakes:

• Expecting agent to generate unrelated text
• Assuming error due to lambda function
• Thinking response is empty

4. Consider this code snippet:

tools = [Tool(name='Calc', func=lambda x: eval(x))]
llm = OpenAI(temperature=0)
agent = initialize_agent(llm, tools, agent_type='zero-shot')
result = agent.run('2 + 2')

What is the main error in this code?

medium

A. The agent_type 'zero-shot' is not supported

B. The order of arguments in initialize_agent is incorrect

C. The OpenAI model is not initialized properly

D. The lambda function in tools is invalid

Solution

1. Step 1: Check initialize_agent argument order

   The correct order is tools first, then llm. Here, llm is first, tools second.

2. Step 2: Verify other parts

   Lambda function is valid, OpenAI initialized correctly, and 'zero-shot' is a valid agent_type.

3. Final Answer:

   The order of arguments in initialize_agent is incorrect -> Option B

4. Quick Check:

   initialize_agent args order = tools, llm [OK]

Hint: Tools must come before llm in initialize_agent [OK]

Common Mistakes:

• Swapping tools and llm arguments
• Assuming lambda syntax error
• Thinking agent_type is invalid

5. You want to build a LangChain agent that can both search the web and perform calculations. Which approach correctly sets up the agent to handle both tasks?

hard

A. Use only a language model without tools, since it can do both tasks

B. Create a single tool that tries to do both search and calculations inside one function

C. Initialize two separate agents, one for search and one for calculations, and call them separately

D. Define two tools, one for web search and one for calculations, then initialize the agent with both tools and a language model

Solution

1. Step 1: Understand multi-tool agent setup

   LangChain agents can use multiple tools to handle different tasks flexibly.

2. Step 2: Evaluate options for combining tasks

   Define two tools, one for web search and one for calculations, then initialize the agent with both tools and a language model correctly defines separate tools for each task and connects them to one agent.

3. Final Answer:

   Define two tools, one for web search and one for calculations, then initialize the agent with both tools and a language model -> Option D

4. Quick Check:

   Multiple tools + one agent = flexible multitasking [OK]

Hint: Use separate tools for each task, combine in one agent [OK]

Common Mistakes:

• Trying to combine tasks in one tool function
• Using multiple agents instead of one
• Relying only on language model without tools