Exploring OpenAI's Agents SDK: A Comprehensive Guide

Step-by-Step Tutorial

Introduction

In this tutorial, you will learn how to use OpenAI's Agents SDK to build and manage AI agents. We'll cover essential features such as agent initialization, running agents asynchronously, using tools, implementing guard rails, and creating conversational agents. By the end of this tutorial, you'll have a solid understanding of how to leverage the Agents SDK for your AI projects.

Prerequisites

• Basic understanding of Python programming
• An OpenAI account and API key
• Python environment set up with pip

Steps

Step 1: Install the Agents SDK and Set Up Your API Key

First, you need to install the Agents SDK using pip. Then, you'll need to obtain an OpenAI API key from the OpenAI platform.

pip install openai-agents-sdk

Notes:

• Make sure you have an OpenAI account. If not, sign up at platform.openai.com.
• Navigate to the API keys section on the OpenAI platform and create a new secret key. Name it something like 'agents_sdk'.

Step 2: Initialize a Simple Agent

To start, you'll initialize a simple agent with a name and a system prompt. This agent will use the GPT-4o mini model.

from openai_agents_sdk import Agent, Runner

agent = Agent(name='system', system_prompt='You are a helpful assistant.', model='gpt-4o-mini')

Notes:

• The system prompt defines the behavior of your agent. Adjust it according to your needs.

Step 3: Run the Agent Asynchronously

You can run your agent using different methods provided by the Runner class. We'll use the asynchronous run method to generate a short story.

runner = Runner(agent)
response = runner.run('Tell me a short story.')
print(response)

Notes:

• Asynchronous methods are recommended for better scalability and efficiency in production environments.

Step 4: Run the Agent with Streaming

For a better user experience, you can run the agent with streaming to see the output as it's generated. This is particularly useful for user-facing applications.

for event in runner.run_streamed('Hello there'):
    print(event)

Notes:

• Streaming allows you to see the output as it's being generated, improving user experience.

Step 5: Define and Use Tools

Tools allow your agent to perform specific functions. We'll define a simple multiplication tool and use it within our agent.

from openai_agents_sdk import function_tool

@function_tool
def multiply(x: float, y: float) -> float:
    """Multiply two numbers together."""
    return x * y

agent_with_tool = Agent(name='system', system_prompt='You are a helpful assistant. Use tools to answer queries.', tools=[multiply])
runner_with_tool = Runner(agent_with_tool)
response = runner_with_tool.run_streamed('Multiply 5 by 3.')
for event in response:
    print(event)

Notes:

• Use type annotations and docstrings to provide clear instructions to the agent about the tool's function.

Step 6: Implement Input Guard Rails

Guard rails help control the input and output of your agent. We'll implement an input guard rail to prevent the agent from discussing political opinions.

from openai_agents_sdk import Agent, input_guardrail, GuardOutput

@input_guardrail
def politics_guardrail(input: str, context: dict) -> GuardOutput:
    agent = Agent(name='politics_guard', system_prompt='Check if the user is asking about political opinions.', output_type=GuardOutput)
    response = agent.run(input)
    return response

safe_agent = Agent(name='system', system_prompt='You are a helpful assistant.', input_guardrails=[politics_guardrail])
safe_runner = Runner(safe_agent)
try:
    response = safe_runner.run('What do you think about the Labor Party in the UK?')
except Exception as e:
    print(f'Guard rail triggered: {e}')

Notes:

• Guard rails are crucial for maintaining the integrity and safety of your agent's interactions.

Step 7: Create a Conversational Agent

To make your agent conversational, you need to manage a list of interactions over time. We'll show how to remember a number and use it in a subsequent query.

from openai_agents_sdk import Agent, Runner

agent = Agent(name='system', system_prompt='You are a helpful assistant.')
runner = Runner(agent)

# First interaction
response = runner.run('Remember the number 7814 for me.')
print(response)

# Convert the response to an input list
input_list = runner.to_input_list(response)

# Second interaction
next_message = {'role': 'user', 'content': 'Multiply the last number you remembered by 103.8.'}
input_list.append(next_message)

# Run the agent with the input list
response = runner.run(input_list)
print(response)

Notes:

• Conversational agents require managing a history of interactions to maintain context.

Conclusion

In this tutorial, you've learned how to set up and use OpenAI's Agents SDK to create and manage AI agents. You've covered initializing agents, running them asynchronously, using tools, implementing guard rails, and creating conversational agents. As you continue to explore the SDK, consider experimenting with more complex agent interactions and integrating it into your own projects. Keep an eye on future updates and additional features that OpenAI may introduce to enhance your agent-building capabilities.