### Introduction

In this blog post, we will walk through an example of using the OpenAI Swarm framework to create a multi-agent system. This system will include agents for fetching weather data and stock prices. We'll use the OpenWeatherMap API for weather data and the yfinance library for stock prices. Let's dive into the code step by step.

## Prerequisites

First, make sure you have the necessary libraries installed. You can install them using pip:

```yaml
pip install git+https://github.com/openai/swarm.git yfinance
```

Next, set your API keys as environment variables:

```jsx
OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxx
OPENWEATHER_API_KEY=xxxxxxxxxxxxxxxx
```

## Import Libraries

Start by importing the necessary libraries:

```python
import os
import requests
import yfinance as yf
from swarm import Swarm, Agent
```

## Initialize Swarm Client

Initialize the Swarm client:

```python
# Initialize Swarm client
client = Swarm()
```

## Load API Key

Load the OpenWeatherMap API key from the environment variable:

```python
# Load OpenWeatherMap API key from environment variable
API_KEY = os.getenv('OPENWEATHER_API_KEY')
if not API_KEY:
    raise ValueError("OPENWEATHER_API_KEY environment variable not set")

BASE_URL = "http://api.openweathermap.org/data/2.5/weather"
```

## Fetch Weather Data

Define a function to fetch real weather data:

```python
# Function to fetch real weather data
def get_weather(location):
    print(f"Running weather function for {location}...")

    params = {
        "q": location,
        "appid": API_KEY,
        "units": "metric"  # Change to 'imperial' for Fahrenheit
    }
    response = requests.get(BASE_URL, params=params)
    data = response.json()

    if response.status_code == 200:
        temperature = data['main']['temp']
        weather_description = data['weather'][0]['description']
        city_name = data['name']
        return f"The weather in {city_name} is {temperature}°C with {weather_description}."
    else:
        return f"Could not get the weather for {location}. Please try again."
```

## Fetch Stock Price

Define a function to fetch stock prices using yfinance:

```python
# Function to fetch stock price using yfinance
def get_stock_price(ticker):
    print(f"Running stock price function for {ticker}...")
    stock = yf.Ticker(ticker)
    stock_info = stock.history(period="1d")
    if not stock_info.empty:
        latest_price = stock_info['Close'].iloc[-1]
        return f"The latest stock price for {ticker} is {latest_price}."
    else:
        return f"Could not retrieve stock price for {ticker}."
```

## Transfer Functions

Define functions to transfer control between agents:

```python
# Function to transfer from manager agent to weather agent
def transfer_to_weather_assistant():
    print("Transferring to Weather Assistant...")
    return weather_agent

# Function to transfer from manager agent to stock price agent
def transfer_to_stockprice_assistant():
    print("Transferring to Stock Price Assistant...")
    return stockprice_agent
```

## Define Agents

Define the manager agent, weather agent, and stock price agent:

```python
# manager Agent
manager_agent = Agent(
    name="manager Assistant",
    instructions="You help users by directing them to the right assistant.",
    functions=[transfer_to_weather_assistant, transfer_to_stockprice_assistant],
)

# Weather Agent
weather_agent = Agent(
    name="Weather Assistant",
    instructions="You provide weather information for a given location using the provided tool",
    functions=[get_weather],
)

# Stock Price Agent
stockprice_agent = Agent(
    name="Stock Price Assistant",
    instructions="You provide the latest stock price for a given ticker symbol using the yfinance library.",
    functions=[get_stock_price],
)
```

## Run the Manager Agent

Run the manager agent to handle user queries:

```python
print("Running manager Assistant for Weather...")
response = client.run(
    agent=manager_agent,
    messages=[{"role": "user", "content": "What's the weather in New York?"}],
)
print(response.messages[-1]["content"])

# Example: User query handled by manager agent to get stock price
print("\nRunning manager Assistant for Stock Price...")
response = client.run(
    agent=manager_agent,
    messages=[{"role": "user", "content": "Get me the stock price of AAPL."}],
)

print(response.messages[-1]["content"])
```

## Conclusion

This example demonstrates how to create a multi-agent system using the OpenAI Swarm framework. The manager agent directs user queries to the appropriate assistant agents, which then fetch and return the requested information. This setup allows for a modular and scalable approach to handling various types of user requests.


OpenAI Swarm framework to create a multi-agent system

Hamdi Khalifi

Hamdi Khalifi

OpenAI Swarm Example

Introduction

Prerequisites

Import Libraries

Initialize Swarm Client

Load API Key

Fetch Weather Data

Fetch Stock Price

Transfer Functions

Define Agents

Run the Manager Agent

Conclusion

Tags:

Comments (0)