AI Agents Specialization — Start Here¶
Overview of the Agents track: function calling, ReAct, LangGraph, multi-agent systems, memory, and production deployment.
Agent Architecture¶
┌─────────────────────────────────────────────────────┐
│ AI AGENT │
├─────────────────────────────────────────────────────┤
│ │
│ User Input │
│ ↓ │
│ ┌──────────┐ │
│ │ LLM │ ← Planning & Reasoning │
│ │ Brain │ │
│ └────┬─────┘ │
│ │ │
│ ↓ │
│ ┌──────────────────────────┐ │
│ │ Tool Selection │ │
│ └────┬─────────────────────┘ │
│ │ │
│ ↓ │
│ ┌──────────────────────────┐ │
│ │ Tool Execution │ │
│ │ - Web Search │ │
│ │ - Database Query │ │
│ │ - Code Execution │ │
│ │ - API Calls │ │
│ └────┬─────────────────────┘ │
│ │ │
│ ↓ │
│ ┌──────────┐ │
│ │ Memory │ ← Short & Long-term │
│ └──────────┘ │
│ │ │
│ ↓ │
│ Final Response │
│ │
└─────────────────────────────────────────────────────┘
Quick Demo: Calculator Agent¶
Let’s build a simple agent that can do math:
# Install dependencies (uncomment to run)
# !pip install openai
import json
import re
from typing import Dict, List, Any
class SimpleAgent:
"""A simple calculator agent"""
def __init__(self):
self.tools = {
"calculator": self.calculator,
"is_prime": self.is_prime
}
self.conversation_history = []
def calculator(self, expression: str) -> float:
"""Evaluate a mathematical expression"""
try:
# Safe evaluation (limited to math operations)
result = eval(expression, {"__builtins__": {}}, {})
return result
except Exception as e:
return f"Error: {str(e)}"
def is_prime(self, n: int) -> bool:
"""Check if a number is prime"""
if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
def run(self, query: str, max_iterations: int = 5) -> str:
"""Run the agent loop"""
print(f"🤖 Agent received: {query}\n")
# Simple reasoning (in real agent, LLM does this)
iterations = 0
while iterations < max_iterations:
iterations += 1
print(f"--- Iteration {iterations} ---")
# Decide what to do (simplified)
if "sum" in query.lower() or "+" in query:
# Extract numbers
numbers = re.findall(r'\d+', query)
if len(numbers) >= 2:
expr = " + ".join(numbers)
print(f"💭 Thought: I need to calculate {expr}")
print(f"🔧 Action: calculator({expr})")
result = self.calculator(expr)
print(f"📊 Result: {result}\n")
return f"The answer is {result}"
elif "prime" in query.lower():
# Extract number from query
numbers = re.findall(r'\d+', query)
if numbers:
num = int(numbers[0])
thought = f"I need to check if {num} is prime"
print(f"💭 Thought: {thought}")
print(f"🔧 Action: is_prime({num})")
result = self.is_prime(num)
print(f"📊 Result: {result}\n")
if result:
return f"Yes, {num} is a prime number"
else:
return f"No, {num} is not a prime number"
# If we can't determine action, return
return "I'm not sure how to help with that."
return "Max iterations reached"
# Create and test agent
agent = SimpleAgent()
print("=" * 60)
response = agent.run("What is 23 + 45?")
print(f"✅ Final Answer: {response}")
print("=" * 60)
ReAct Pattern¶
The ReAct (Reasoning + Acting) pattern is the core of modern agents:
1. THOUGHT: Analyze the problem
2. ACTION: Choose and execute a tool
3. OBSERVATION: See the result
4. REPEAT until solved
5. ANSWER: Provide final response
Example¶
Query: “What’s the weather in the capital of France?”
Iteration 1:
THOUGHT: I need to find the capital of France first
ACTION: search(“capital of France”)
OBSERVATION: “Paris”
Iteration 2:
THOUGHT: Now I can get the weather for Paris
ACTION: get_weather(“Paris”)
OBSERVATION: “72°F, sunny”
Final Answer: “The weather in Paris (capital of France) is 72°F and sunny”
What’s Next?¶
In the following notebooks, you’ll learn:
Function Calling - OpenAI/Anthropic function calling
ReAct Pattern - Build reasoning agents
LangGraph - State machines for complex workflows
Multi-Agent Systems - Agent collaboration
Memory & State - Long-term memory systems
Production - Deploy and monitor agents
🚀 Ready to build intelligent agents!
Key Concepts¶
1. Tools/Functions¶
External capabilities the agent can use:
Web search
Database queries
Code execution
API calls
File operations
2. Planning¶
Breaking complex tasks into steps:
Task decomposition
Step sequencing
Error recovery
Parallel execution
3. Memory¶
Retaining context across interactions:
Short-term (conversation)
Long-term (knowledge base)
Episodic (past experiences)
Semantic (facts and concepts)
4. Reasoning¶
Deciding what to do next:
Chain-of-thought
ReAct pattern
Tree-of-thought
Self-reflection