Azure for AI Agents

# Install Azure CLI (macOS)
brew install azure-cli

# Login
az login

# Set subscription
az account set \
  --subscription "My AI Sub"

# Create resource group
az group create \
  --name ai-agent-rg \
  --location eastus

# Verify
az account show --output table

# Install Azure SDKs
pip install openai
pip install azure-identity
pip install azure-cosmos
pip install azure-storage-blob

# Quick test with DefaultCredential
python3 -c "
  from azure.identity import \
    DefaultAzureCredential
  cred = DefaultAzureCredential()
  token = cred.get_token(
    'https://management.azure.com'
  )
  print('Auth OK')
"

# Create Azure OpenAI resource
az cognitiveservices account create \
  --name my-openai \
  --resource-group ai-agent-rg \
  --kind OpenAI \
  --sku S0 \
  --location eastus

# Deploy a model
az cognitiveservices account \
  deployment create \
  --name my-openai \
  --resource-group ai-agent-rg \
  --deployment-name gpt-4o \
  --model-name gpt-4o \
  --model-version "2024-11-20" \
  --model-format OpenAI \
  --sku-capacity 10 \
  --sku-name Standard

# Invoke GPT-4o via Azure OpenAI
from openai import AzureOpenAI

client = AzureOpenAI(
  azure_endpoint="https://my-openai"
    ".openai.azure.com",
  api_key=os.getenv("AZURE_KEY"),
  api_version="2024-10-21"
)

response = client.chat.completions
  .create(
  model="gpt-4o",
  messages=[{
    "role": "user",
    "content": "Plan an agent"
    " architecture"
  }]
)

print(response.choices[0]
  .message.content)

# Store and retrieve agent state
from azure.cosmos import CosmosClient

client = CosmosClient(url, credential)
db = client.get_database_client(
  "agent-db"
)
container = db.get_container_client(
  "sessions"
)

# Save agent session
container.upsert_item({
  "id": "sess_abc123",
  "agent_id": "research-agent",
  "state": "reasoning",
  "messages": [...],
  "ttl": 86400
})

# Query sessions
items = container.query_items(
  query="SELECT * FROM c"
    " WHERE c.state='active'"
)

# function_app.py (v2 model)
import azure.functions as func
import json

app = func.FunctionApp()

@app.route(route="agent/tool")
def execute_tool(req: func.HttpRequest):
  body = req.get_json()
  tool = body["tool_name"]
  params = body["parameters"]

  if tool == "search":
    result = search(params)
  elif tool == "read_blob":
    result = read_blob(params)

  return func.HttpResponse(
    json.dumps(result),
    mimetype="application/json"
  )

# Distribute tasks across agents
from azure.servicebus import \
  ServiceBusClient, ServiceBusMessage

client = ServiceBusClient
  .from_connection_string(conn_str)

# Send task to queue
with client.get_queue_sender(
  "agent-tasks"
) as sender:
  sender.send_messages(
    ServiceBusMessage(json.dumps({
      "task": "analyze_doc",
      "blob": "docs/report.pdf",
      "priority": "high"
    }))
  )