AI agents are popping up everywhere these days, and there's a solid reason behind it. They're completely changing how we work with software, going way past basic chat systems to become tools that can genuinely take action for us.

You'll find everything from support bots handling return requests to programming helpers that can solve problems across entire codebases. These agents are quickly becoming the bridge that connects people with complicated technology.

Here's what's interesting though: a lot of what people call "agents" really aren't agents in the true sense. They're basically chatbots running on predetermined responses. Today, we're going to create an actual agent that can analyze situations, make choices, and take independent action. The best part is we'll break it down so anyone starting out can understand it completely.

Ready to get started? But before we jump in:

What Actually Defines a Real AI Agent?

What are we talking about when we say "genuine agent"?

The main difference between an actual agent and basic automation comes down to independence and flexible thinking. Here's a way to picture it:

Workflows work like following a recipe step by step—when you run out of an ingredient, you're stuck.
Agents function like an experienced chef who can substitute ingredients and adjust the dish based on what's available.

Workflows handle straightforward, predictable tasks really well, but they typically struggle when faced with unpredictable situations or changing requirements, which is where agents really shine.

What We're Going to Create

Using the OpenAI SDK, we'll put together a straightforward stock information agent that can handle questions about stocks and companies. Here's what it will do:

Get current stock prices through the Yahoo Finance API.
Look up company executives from stock information.
Convert company names into their trading symbols.
Request clarification when questions aren't clear enough.

What transforms this into a genuine agent is how it independently chooses:

Which function to apply for different questions.
When to combine several functions in sequence.
When to reach out to users for additional details.
How to recover from problems and try alternative methods.

What You'll Need to Get Started

Here's your setup checklist:

Python version 3.7 or newer.
An OpenAI API key (grab one from platform.openai.com).
Some familiarity with Python basics.

Set up a new project folder and add the necessary packages:

mkdir stock-info-agent

cd stock-info-agent

pip install openai yfinance python-dotenv

Create a .env file in your project directory:

OPENAI_API_KEY=your_api_key_here

Building the Agent: A Step-by-Step Walkthrough

Let's construct this agent piece by piece, making sure we understand every part as we go.

1. Setting Up the Agent Class

First, we create our agent class with OpenAI integration:

import json

from typing import Optional, Dict, Any, List

from openai import OpenAI

import yfinance as yf

from dotenv import load_dotenv

import os

load_dotenv()

class StockInfoAgent:

def __init__(self):

self.client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

self.conversation_history = []

The conversation_history is crucial – it allows our agent to maintain context across multiple interactions, understanding, for example, that "their CEO" refers to the company discussed earlier.

2. Creating the Tools

Our agent needs tools to interact with the real world. Let's create them:

Stock Price Tool

def get_stock_price(self, ticker_symbol: str) -> Optional[str]:

"""Fetches the current stock price for the given ticker_symbol."""

try:

stock = yf.Ticker(ticker_symbol.upper())

info = stock.info

current_price = info.get('currentPrice') or info.get('regularMarketPrice')

if current_price:

return f"{current_price:.2f} USD"return None

except Exception as e:

print(f"Error fetching stock price: {e}")

return None

This function connects to Yahoo Finance for live stock price data. Pay attention to how it manages errors reliable agents need to handle problems smoothly without breaking down.

CEO Finder Tool

def get_company_ceo(self, ticker_symbol: str) -> Optional[str]:

"""Fetches the name of the CEO for the company associated with the ticker_symbol."""

try:

stock = yf.Ticker(ticker_symbol.upper())

info = stock.info

# Look for CEO in various possible fields

ceo = None

for field in ['companyOfficers', 'officers']:

if field in info:

officers = info[field]

if isinstance(officers, list):

for officer in officers:

if isinstance(officer, dict):

title = officer.get('title', '').lower()

if 'ceo' in title or 'chief executive' in title:

ceo = officer.get('name')

break

return ceo

except Exception as e:

print(f"Error fetching CEO info: {e}")

return None

This tool searches through different data structures to find the CEO, as Yahoo Finance doesn't have a standardized format.

Ticker Symbol Finder Tool

This tool is crucial for handling natural language queries about companies:

def find_ticker_symbol(self, company_name: str) -> Optional[str]:

"""Tries to identify the stock ticker symbol for a given company_name."""

try:

# Use yfinance Lookup to search for the company

lookup = yf.Lookup(company_name)

stock_results = lookup.get_stock(count=5)

if not stock_results.empty:

return stock_results.index[0]

# If no stocks found, try all instruments

all_results = lookup.get_all(count=5)

if not all_results.empty:

return all_results.index[0]

except Exception as e:

print(f"Error searching for ticker: {e}")

return None

This tool allows users to refer to companies by name ("Apple", "Tesla", "that EV company") instead of needing to know ticker symbols.

The Clarification Tool

This is what makes our agent truly interactive, allowing it to ask the user for clarification when needed.

def ask_user_for_clarification(self, question_to_user: str) -> str:

"""Poses the question_to_user to the actual user and returns their typed response."""

print(f"\nAgent needs clarification: {question_to_user}")

response = input("Your response: ")

return response

3. Defining Tools for OpenAI

The agent needs to know what tools are available and how to use them. We define them in OpenAI's function calling format:

def create_tool_definitions(self) -> List[Dict[str, Any]]:

"""Creates OpenAI function calling definitions for the tools."""

return [

{

"type": "function",

"function": {

"name": "get_stock_price",

"description": "Fetches the current stock price for the given ticker symbol",

"parameters": {

"type": "object",

"properties": {

"ticker_symbol": {

"type": "string",

"description": "The stock ticker symbol (e.g., 'AAPL', 'MSFT')"

}

},

"required": ["ticker_symbol"]

}

}

},

# ... (other tool definitions)

]

These definitions are like instruction manuals for the AI they tell it what each tool does and what parameters it needs.

4. The Brain: Processing User Queries

Here's where the magic happens the agent's decision-making loop:

def process_user_query(self, user_query: str) -> str:

"""Processes a user query using the OpenAI API with function calling."""

self.conversation_history.append({"role": "user", "content": user_query})

system_prompt = """You are a helpful stock information assistant. You have access to tools that can:

1. Get current stock prices

2. Find company CEOs

3. Find ticker symbols for company names

4. Ask users for clarification when needed

Use these tools to help answer user questions about stocks and companies.

If information is ambiguous, ask for clarification."""

while True:

messages = [

{"role": "system", "content": system_prompt},

*self.conversation_history

]

# Call OpenAI API with function calling

response = self.client.chat.completions.create(

model="gpt-4-turbo-preview",

messages=messages,

tools=self.create_tool_definitions(),

tool_choice="auto" # Let the model decide which tool to use

)

response_message = response.choices[0].message

# If no tool calls, we're done

if not response_message.tool_calls:

self.conversation_history.append({"role": "assistant", "content": response_message.content})

return response_message.content

# Execute the tool the agent chose

tool_call = response_message.tool_calls[0]

function_name = tool_call.function.name

function_args = json.loads(tool_call.function.arguments)

print(f"\nExecuting tool: {function_name} with args: {function_args}")

# Execute the tool

result = self.execute_tool(function_name, function_args)

# Add everything to conversation history

self.conversation_history.append({

"role": "assistant",

"content": None,

"tool_calls": [{

"id": tool_call.id,

"type": "function",

"function": {

"name": function_name,

"arguments": json.dumps(function_args)

}

}]

})

self.conversation_history.append({

"tool_call_id": tool_call.id,

"role": "tool",

"name": function_name,

"content": str(result) if result is not None else "No result found"

})

The key insight here is the while True loop—the agent keeps thinking and acting until it has a complete answer. It might use one tool, or five, or ask for clarification multiple times. This is true autonomy.

See Our Agent In Action

Here's a real conversation that demonstrates our agent's capabilities very well:

You: Who is the CEO of the EV company from China and what is its stock price?

Executing tool: ask_user_for_clarification with args: {'question_to_user': 'Are you referring to NIO, XPeng, or another Chinese EV company?'}

Agent needs clarification: Are you referring to NIO, XPeng, or another Chinese EV company?

Your response: BYD

Executing tool: find_ticker_symbol with args: {'company_name': 'BYD'}

Executing tool: get_company_ceo with args: {'ticker_symbol': 'BYDDF'}

Executing tool: get_stock_price with args: {'ticker_symbol': 'BYDDF'}

Agent: The CEO of BYD, the Chinese EV company, is Mr. Chuan-Fu Wang, and its current stock price is $59.50 USD.

The agent worked independently by:

Understanding that "EV company from China" wasn't specific enough.
Requesting clarification on which exact company.
Located BYD's trading symbol.
Pulled up the CEO details.
Got the latest stock price.
Put together a comprehensive response.

How to Use the Agent

Running the agent is simple, navigate to the project directory and run the following command:

python stock_agent.py

Try these example queries to see different behaviors:

Simple query:

You: What's Apple's stock price?

Agent: Apple's current stock price is $182.63 USD.

Ambiguous query requiring clarification:

You: Who runs that big EV company?

Agent: Are you asking about the CEO of Tesla?

You: Yes

Agent: The CEO of Tesla is Mr. Elon R. Musk.

Complex multi-tool query:

You: Compare the stock prices of Microsoft and Apple

Agent: Microsoft (MSFT) is currently trading at $415.26 USD, while Apple (AAPL) is trading at $182.63 USD.

Extending Your Agent

The modular design makes it easy to add new capabilities:

Add Market Analysis

def get_price_change(self, ticker_symbol: str, period: str = "1d") -> Dict[str, Any]:

"""Get price change over a period"""

stock = yf.Ticker(ticker_symbol)

hist = stock.history(period=period)

if len(hist) >= 2:

start_price = hist['Close'].iloc[0]

end_price = hist['Close'].iloc[-1]

change = end_price - start_price

percent_change = (change / start_price) * 100

return {

"change": f"${change:.2f}",

"percent": f"{percent_change:.2f}%"}

Add News Integration

def get_company_news(self, ticker_symbol: str) -> List[Dict[str, str]]:

"""Get recent news about the company"""

stock = yf.Ticker(ticker_symbol)

news = stock.news

return [{"title": item['title'], "link": item['link']} for item in news[:5]]

Best Practices for Creating Agents

Write Clear Function Descriptions: Explain each tool like you're talking to a teammate
Handle Problems Smoothly: Always plan for API issues and missing information
Keep Track of Conversations: Store previous exchanges for natural flow
Be Open with Users: Let them see which functions are running
Begin with Basics: Only add complicated features when they're actually necessary

For more helpful tips, check out Anthropic's guide.

The Complete Code

import json

from typing import Optional, Dict, Any, List

from openai import OpenAI

import yfinance as yf

from dotenv import load_dotenv

import os

# Load environment variables

load_dotenv()

class StockInfoAgent:

def __init__(self):

self.client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

self.conversation_history = []

def get_stock_price(self, ticker_symbol: str) -> Optional[str]:

"""Fetches the current stock price for the given ticker_symbol."""

try:

stock = yf.Ticker(ticker_symbol.upper())

info = stock.info

current_price = info.get('currentPrice') or info.get('regularMarketPrice')

if current_price:

return f"{current_price:.2f} USD"return None

except Exception as e:

print(f"Error fetching stock price: {e}")

return None

def get_company_ceo(self, ticker_symbol: str) -> Optional[str]:

"""Fetches the name of the CEO for the company associated with the ticker_symbol."""

try:

stock = yf.Ticker(ticker_symbol.upper())

info = stock.info

# Look for CEO in various possible fields

ceo = None

for field in ['companyOfficers', 'officers']:

if field in info:

officers = info[field]

if isinstance(officers, list):

for officer in officers:

if isinstance(officer, dict):

title = officer.get('title', '').lower()

if 'ceo' in title or 'chief executive' in title:

ceo = officer.get('name')

break

# Fallback to general company info

if not ceo and 'longBusinessSummary' in info:

ceo = None

return ceo

except Exception as e:

print(f"Error fetching CEO info: {e}")

return None

def find_ticker_symbol(self, company_name: str) -> Optional[str]:

"""Tries to identify the stock ticker symbol for a given company_name."""

try:

# Use yfinance Lookup to search for the company

lookup = yf.Lookup(company_name)

stock_results = lookup.get_stock(count=5)

if not stock_results.empty:

return stock_results.index[0]

# If no stocks found, try all instruments

all_results = lookup.get_all(count=5)

if not all_results.empty:

return all_results.index[0]

except Exception as e:

print(f"Error searching for ticker: {e}")

return None

def ask_user_for_clarification(self, question_to_user: str) -> str:

"""Poses the question_to_user to the actual user and returns their typed response."""

print(f"\nAgent needs clarification: {question_to_user}")

response = input("Your response: ")

return response

def create_tool_definitions(self) -> List[Dict[str, Any]]:

"""Creates OpenAI function calling definitions for the tools."""

return [

{

"type": "function",

"function": {

"name": "get_stock_price",

"description": "Fetches the current stock price for the given ticker symbol",

"parameters": {

"type": "object",

"properties": {

"ticker_symbol": {

"type": "string",

"description": "The stock ticker symbol (e.g., 'AAPL', 'MSFT')"

}

},

"required": ["ticker_symbol"]

}

}

},

{

"type": "function",

"function": {

"name": "get_company_ceo",

"description": "Fetches the name of the CEO for the company associated with the ticker symbol",

"parameters": {

"type": "object",

"properties": {

"ticker_symbol": {

"type": "string",

"description": "The stock ticker symbol"

}

},

"required": ["ticker_symbol"]

}

}

},

{

"type": "function",

"function": {

"name": "find_ticker_symbol",

"description": "Tries to identify the stock ticker symbol for a given company name",

"parameters": {

"type": "object",

"properties": {

"company_name": {

"type": "string",

"description": "The name of the company"

}

},

"required": ["company_name"]

}

}

},

{

"type": "function",

"function": {

"name": "ask_user_for_clarification",

"description": "Poses a question to the user and returns their response",

"parameters": {

"type": "object",

"properties": {

"question_to_user": {

"type": "string",

"description": "The question to ask the user"

}

},

"required": ["question_to_user"]

}

}

}

]

def execute_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Any:

"""Executes the specified tool with given arguments."""

if tool_name == "get_stock_price":

return self.get_stock_price(arguments["ticker_symbol"])

elif tool_name == "get_company_ceo":

return self.get_company_ceo(arguments["ticker_symbol"])

elif tool_name == "find_ticker_symbol":

return self.find_ticker_symbol(arguments["company_name"])

elif tool_name == "ask_user_for_clarification":

return self.ask_user_for_clarification(arguments["question_to_user"])

else:

return None

def process_user_query(self, user_query: str) -> str:

"""Processes a user query using the OpenAI API with function calling."""

# Add user message to conversation history

self.conversation_history.append({"role": "user", "content": user_query})

system_prompt = """You are a helpful stock information assistant. You have access to tools that can:

1. Get current stock prices

2. Find company CEOs

3. Find ticker symbols for company names

4. Ask users for clarification when needed

Use these tools to help answer user questions about stocks and companies. If information is ambiguous, ask for clarification."""

while True:

messages = [

{"role": "system", "content": system_prompt},

*self.conversation_history

]

# Call OpenAI API with function calling

response = self.client.chat.completions.create(

model="gpt-4-turbo-preview",

messages=messages,

tools=self.create_tool_definitions(),

tool_choice="auto"

)

response_message = response.choices[0].message

# If no tool calls, we're done

if not response_message.tool_calls:

self.conversation_history.append({"role": "assistant", "content": response_message.content})

return response_message.content

# Execute the first tool call

tool_call = response_message.tool_calls[0]

function_name = tool_call.function.name

function_args = json.loads(tool_call.function.arguments)

print(f"\nExecuting tool: {function_name} with args: {function_args}")

# Execute the tool

result = self.execute_tool(function_name, function_args)

# Add the assistant's message with tool calls to history

self.conversation_history.append({

"role": "assistant",

"content": None,

"tool_calls": [{

"id": tool_call.id,

"type": "function",

"function": {

"name": function_name,

"arguments": json.dumps(function_args)

}

}]

})

# Add tool result to history

self.conversation_history.append({

"tool_call_id": tool_call.id,

"role": "tool",

"name": function_name,

"content": str(result) if result is not None else "No result found"

})

def chat(self):

"""Interactive chat loop."""

print("Stock Information Agent")

print("Ask me about stock prices, company CEOs, or any stock-related questions!")

print("Type 'quit' to exit.\n")

while True:

user_input = input("You: ")

if user_input.lower() in ['quit', 'exit', 'bye']:

print("Goodbye!")

break

try:

response = self.process_user_query(user_input)

print(f"\nAgent: {response}\n")

except Exception as e:

print(f"\nError: {e}\n")

if __name__ == "__main__":

agent = StockInfoAgent()

agent.chat()

Access Full Code Here: GitHub File

Wrapping Up

You did it! You've created a genuine AI agent that can analyze, choose, and take action on its own. This goes beyond a simple chatbot running scripts. You've built an intelligent system that handles unclear questions, seeks clarification, and connects different tools to tackle complicated tasks.

The main points to remember:

Real agents figure out their own approach to solving problems
Straightforward, flexible designs work better than complicated frameworks
Build with essential tools first and expand only when necessary
Keeping conversation history and managing errors properly are essential

With what you've learned here, you can create agents for any field, whether that's analyzing finances, helping customers, or building personal helpers. The opportunities are limitless when you give AI the power to think and act independently.

Good luck with your projects, and we're excited to see what you create!