OpenAI functions agent in LangChain - Mini Project: Build & Apply

Build a Simple OpenAI Functions Agent with LangChain

📖 Scenario: You want to create a small assistant that can answer questions by calling a function you define. This is useful when you want your AI to do specific tasks like math or fetching data.

🎯 Goal: Build a LangChain OpenAI Functions agent that uses a custom function to answer questions about simple math operations.

📋 What You'll Learn

Create a function that adds two numbers

Set up a LangChain OpenAI Functions agent

Configure the agent to use the custom addition function

Run the agent to answer a math question using the function

💡 Why This Matters

🌍 Real World

OpenAI Functions agents let you connect AI chat models to your own code, so the AI can perform tasks like calculations, database queries, or API calls automatically.

💼 Career

Understanding how to build OpenAI Functions agents is useful for AI developers, chatbot creators, and software engineers who want to integrate AI with custom business logic.

1

Create the addition function

Write a Python function called add_numbers that takes two parameters a and b and returns their sum.

LangChain

# Your code here
def add_numbers(a, b):
    # Your code here

Hint

Think of a function that takes two inputs and returns their sum using the return keyword.

2

Set up the OpenAI Functions agent

Import OpenAI and create_openai_functions_agent from langchain. Then create an OpenAI instance called llm with temperature=0.

LangChain

def add_numbers(a, b):
    return a + b

# Your code here
from langchain.chat_models import OpenAI
from langchain.agents import create_openai_functions_agent

llm = OpenAI(temperature=0)

Hint

Use from langchain.chat_models import OpenAI and from langchain.agents import create_openai_functions_agent. Then create llm = OpenAI(temperature=0).

3

Configure the agent with the addition function

Create a list called functions with one dictionary describing the add_numbers function. The dictionary must have keys: name with value 'add_numbers', description with value 'Add two numbers', and parameters describing two required integer properties a and b. Then create the agent by calling create_openai_functions_agent(llm, functions) and assign it to agent.

LangChain

def add_numbers(a, b):
    return a + b

from langchain.chat_models import OpenAI
from langchain.agents import create_openai_functions_agent

llm = OpenAI(temperature=0)

# Your code here
functions = [
    {
        "name": "add_numbers",
        "description": "Add two numbers",
        "parameters": {
            "type": "object",
            "properties": {
                "a": {"type": "integer"},
                "b": {"type": "integer"}
            },
            "required": ["a", "b"]
        }
    }
]

agent = create_openai_functions_agent(llm, functions)

Hint

Define functions as a list with one dictionary describing the function name, description, and parameters. Then create agent using create_openai_functions_agent.

4

Run the agent to answer a math question

Call agent.run with the string 'What is the sum of 5 and 7?' and assign the result to answer.

LangChain

def add_numbers(a, b):
    return a + b

from langchain.chat_models import OpenAI
from langchain.agents import create_openai_functions_agent

llm = OpenAI(temperature=0)

functions = [
    {
        "name": "add_numbers",
        "description": "Add two numbers",
        "parameters": {
            "type": "object",
            "properties": {
                "a": {"type": "integer"},
                "b": {"type": "integer"}
            },
            "required": ["a", "b"]
        }
    }
]

agent = create_openai_functions_agent(llm, functions)

# Your code here
answer = agent.run("What is the sum of 5 and 7?")

Hint

Use answer = agent.run("What is the sum of 5 and 7?") to get the agent's response.

Practice

1. What is the main purpose of an OpenAI functions agent in Langchain?

easy

A. To store large datasets for AI processing

B. To train new AI models from scratch

C. To create user interfaces for AI applications

D. To connect AI chat with your own custom functions for smarter responses

Solution

1. Step 1: Understand the role of an OpenAI functions agent

   An OpenAI functions agent links AI chat capabilities with user-defined functions to perform tasks.

2. Step 2: Compare options to the definition

   Only To connect AI chat with your own custom functions for smarter responses describes connecting AI chat with custom functions, which matches the agent's purpose.

3. Final Answer:

   To connect AI chat with your own custom functions for smarter responses -> Option D

4. Quick Check:

   Agent purpose = connect AI chat + functions [OK]

Hint: Remember: functions agent links AI chat to your code [OK]

Common Mistakes:

• Confusing agent with AI model training
• Thinking it stores data instead of connecting functions
• Assuming it builds user interfaces

2. Which of the following is the correct way to create an OpenAI functions agent in Langchain?

easy

A. agent = OpenAIFunctionsAgent(functions, model)

B. agent = OpenAIChatAgent(model, funcs)

C. agent = OpenAIFunctionsAgent(llm=model, tools=funcs)

D. agent = FunctionsAgent(llm=model, funcs=functions)

Solution

1. Step 1: Recall the correct constructor syntax

   The OpenAI functions agent requires named parameters: llm for the model and tools for the list of tools.

2. Step 2: Check each option for correct names and syntax

   agent = OpenAIFunctionsAgent(llm=model, tools=funcs) uses correct class name and named parameters. Others either use wrong class names or positional arguments incorrectly.

3. Final Answer:

   agent = OpenAIFunctionsAgent(llm=model, tools=funcs) -> Option C

4. Quick Check:

   Correct constructor = agent = OpenAIFunctionsAgent(llm=model, tools=funcs) [OK]

Hint: Look for named parameters llm and tools in constructor [OK]

Common Mistakes:

• Using positional arguments instead of named
• Wrong class names like OpenAIChatAgent
• Mixing parameter names like funcs vs tools

3. Given the code snippet:

from langchain.agents import OpenAIFunctionsAgent

model = OpenAI()
functions = [get_weather, get_news]
agent = OpenAIFunctionsAgent(llm=model, tools=functions)
response = agent.invoke({'input': 'What is the weather today?'})
print(response)

What will print(response) most likely output?

medium

A. A string response from the AI calling get_weather function

B. A syntax error due to missing parameters

C. An empty dictionary because no functions are called

D. A runtime error because invoke method does not exist

Solution

1. Step 1: Understand agent.invoke behavior

   The agent uses the AI model and tools list to process input and call the right function, here likely get_weather.

2. Step 2: Analyze the code flow

   Input asks about weather, so the agent calls get_weather and returns its result as a string response.

3. Final Answer:

   A string response from the AI calling get_weather function -> Option A

4. Quick Check:

   invoke calls function and returns response [OK]

Hint: Input about weather triggers get_weather function call [OK]

Common Mistakes:

• Assuming invoke method does not exist
• Expecting empty output without function calls
• Confusing syntax errors with runtime behavior

4. What is wrong with this code snippet for creating an OpenAI functions agent?

model = OpenAI()
functions = [get_time]
agent = OpenAIFunctionsAgent(functions, model)
response = agent.invoke({'input': 'What time is it?'})

medium

A. The agent constructor is missing named parameters for llm and tools

B. The tools list should be a dictionary, not a list

C. The invoke method requires a string, not a dictionary

D. The OpenAI model must be passed as a string, not an object

Solution

1. Step 1: Check constructor parameter usage

   The OpenAIFunctionsAgent requires named parameters: llm= and tools=, not positional arguments.

2. Step 2: Verify other parts of the code

   Tools as list is correct, invoke accepts a dictionary input, and model is an object as expected.

3. Final Answer:

   The agent constructor is missing named parameters for llm and tools -> Option A

4. Quick Check:

   Constructor needs named params llm= and tools= [OK]

Hint: Always use named parameters llm= and tools= in constructor [OK]

Common Mistakes:

• Passing positional arguments instead of named
• Thinking tools must be a dictionary
• Misunderstanding invoke input type

5. You want to build a Langchain app that answers user questions by calling either get_weather or get_news functions based on input. Which approach correctly sets up the OpenAI functions agent to handle this?

hard

A. Create two separate agents, one for weather and one for news, and switch manually

B. Pass both functions in a list to OpenAIFunctionsAgent and let it decide which to call

C. Use only get_weather function and ignore get_news for simplicity

D. Call functions directly without using an agent

Solution

1. Step 1: Understand agent's function selection

   The OpenAI functions agent can receive multiple functions and uses AI to pick the right one based on input.

2. Step 2: Evaluate options for best design

   Passing both functions in a list lets the agent decide automatically, which is the intended use.

3. Final Answer:

   Pass both functions in a list to OpenAIFunctionsAgent and let it decide which to call -> Option B

4. Quick Check:

   Agent selects function from list automatically [OK]

Hint: Give all functions to agent; it picks based on input [OK]

Common Mistakes:

• Manually switching between agents instead of one agent
• Ignoring needed functions for simplicity
• Bypassing agent and losing AI routing benefits