LangChain agents in Prompt Engineering / GenAI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a basic LangChain agent using an OpenAI LLM.

Prompt Engineering / GenAI

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

llm = OpenAI(temperature=0)
agent = initialize_agent(llm, tools=[], agent= [1] )

Drag options to blanks, or click blank then click option'

A"zero-shot-react-description"

B"chat-completion"

C"simple-agent"

D"tool-using-agent"

Attempts:

3 left

💡 Hint

Common Mistakes

Using an invalid agent type string.

Confusing agent types that require tools with those that don't.

The 'zero-shot-react-description' agent type allows the agent to reason and act without prior examples, suitable for basic LangChain agents.

2fill in blank

medium

Complete the code to add a tool to the LangChain agent's tool list.

Prompt Engineering / GenAI

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

def dummy_tool_func(input_text):
    return "Processed: " + input_text

tool = Tool(name="DummyTool", func=[1], description="A dummy tool.")

llm = OpenAI(temperature=0)
agent = initialize_agent(llm, tools=[tool], agent="zero-shot-react-description")

Drag options to blanks, or click blank then click option'

Alambda x: x

Bdummy_tool_func()

C"dummy_tool_func"

Ddummy_tool_func

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the function call instead of the function object.

Passing the function name as a string.

The 'func' parameter expects a function object, so we pass the function name without parentheses.

3fill in blank

hard

Fix the error in the code to run the LangChain agent with an input query.

Prompt Engineering / GenAI

response = agent.[1]("What is the capital of France?")

Drag options to blanks, or click blank then click option'

Arespond

Brun

Ccall

Dexecute

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-existent method names like 'execute' or 'call'.

Confusing agent methods with other API methods.

The correct method to run the agent on an input is 'run'. Other method names do not exist on the agent object.

4fill in blank

hard

Fill both blanks to create a tool that returns the length of the input text and add it to the agent.

Prompt Engineering / GenAI

from langchain.tools import Tool

def length_tool_func(text):
    return len(text)

tool = Tool(name=[1], func=[2], description="Returns length of input text.")

Drag options to blanks, or click blank then click option'

A"LengthTool"

Blength_tool_func

C"TextLength"

Dlen

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the built-in 'len' function instead of the custom function.

Using a non-string for the tool name.

The tool name should be a string like 'LengthTool', and the function should be the function object 'length_tool_func'.

5fill in blank

hard

Fill all three blanks to create a LangChain agent with a tool that reverses input text and run it on a query.

Prompt Engineering / GenAI

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

def reverse_text(text):
    return text[::-1]

reverse_tool = Tool(name=[1], func=[2], description="Reverses input text.")

llm = OpenAI(temperature=0)
agent = initialize_agent(llm, tools=[reverse_tool], agent=[3])

result = agent.run("Hello World")

Drag options to blanks, or click blank then click option'

A"ReverseTool"

Breverse_text

C"zero-shot-react-description"

D"reverse-agent"

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect agent type strings.

Passing function names as strings instead of function objects.

The tool name is 'ReverseTool', the function is the custom 'reverse_text', and the agent type is 'zero-shot-react-description' for basic reasoning.

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