Python: Add foundry hosted agents samples for python (#4648)

* Add two hosted agent samples using the foundry agent

* Refactor formatting and improve readability in main.py

* Add agent-framework dependency to requirements and update copyright notice in main.py files

* Refactor agent imports and update credential handling in hosted agent samples

* Update agent framework dependency in requirements for hosted agents

* chore: update Python version to 3.14 and improve Dockerfile for hosted agents

* feat: add hosted agent samples for Azure AI with local tools and multi-agent workflows

* fix: update Azure AI client import and refactor agent initialization in hotel agent sample

* feat: add hosted agent samples for Seattle hotel search and writer-reviewer workflow

* fix: correct agent name in YAML configuration for local tools agent
This commit is contained in:
Hui Miao
2026-03-18 16:39:08 +08:00
committed by GitHub
Unverified
parent 705ed47a0b
commit c2fec6b51c
15 changed files with 905 additions and 0 deletions
@@ -0,0 +1,145 @@
# Hosted Agent Samples
These samples demonstrate how to build and host AI agents in Python using the [Azure AI AgentServer SDK](https://pypi.org/project/azure-ai-agentserver-agentframework/) together with Microsoft Agent Framework. Each sample runs locally as a hosted agent and includes `Dockerfile` and `agent.yaml` assets for deployment to Microsoft Foundry.
## Samples
| Sample | Description |
| ----------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| [`agent_with_hosted_mcp`](./agent_with_hosted_mcp/) | Hosted MCP tool that connects to Microsoft Learn via `https://learn.microsoft.com/api/mcp` |
| [`agent_with_text_search_rag`](./agent_with_text_search_rag/) | Retrieval-augmented generation using a custom `BaseContextProvider` with Contoso Outdoors sample data |
| [`agents_in_workflow`](./agents_in_workflow/) | Concurrent workflow that combines researcher, marketer, and legal specialist agents |
| [`agent_with_local_tools`](./agent_with_local_tools/) | Local Python tool execution for Seattle hotel search |
| [`writer_reviewer_agents_in_workflow`](./writer_reviewer_agents_in_workflow/) | Writer/Reviewer workflow using `AzureOpenAIResponsesClient` |
## Common Prerequisites
Before running any sample, ensure you have:
1. Python 3.10 or later
2. [Azure CLI](https://learn.microsoft.com/cli/azure/install-azure-cli) installed
3. An Azure OpenAI resource or a Microsoft Foundry project with a chat model deployment
### Authenticate with Azure CLI
All samples rely on Azure credentials. For local development, the simplest approach is Azure CLI authentication:
```powershell
az login
az account show
```
## Running a Sample
Each sample folder contains its own `requirements.txt`. Run commands from the specific sample directory you want to try.
### Recommended: `uv`
The sample dependencies include preview packages, so allow prerelease installs:
```powershell
cd <sample-directory>
uv venv .venv
uv pip install --prerelease=allow -r requirements.txt
uv run main.py
```
### Alternative: `venv`
Windows PowerShell:
```powershell
cd <sample-directory>
python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -r requirements.txt
python main.py
```
macOS/Linux:
```bash
cd <sample-directory>
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python main.py
```
Each sample starts a hosted agent locally on `http://localhost:8088/`.
## Environment Variable Setup
You can either export variables in your shell or create a local `.env` file in the sample directory.
Example `.env` for Azure OpenAI samples:
```dotenv
AZURE_OPENAI_ENDPOINT=https://<your-openai-resource>.openai.azure.com/
AZURE_OPENAI_CHAT_DEPLOYMENT_NAME=gpt-4.1
```
Example `.env` for Foundry project samples:
```dotenv
PROJECT_ENDPOINT=https://<your-resource>.services.ai.azure.com/api/projects/<your-project>
MODEL_DEPLOYMENT_NAME=gpt-4.1
```
## Interacting with the Agent
After starting a sample, send requests to the Responses endpoint.
PowerShell:
```powershell
$body = @{
input = "Your question here"
stream = $false
} | ConvertTo-Json
Invoke-RestMethod -Uri "http://localhost:8088/responses" -Method Post -Body $body -ContentType "application/json"
```
curl:
```bash
curl -sS -H "Content-Type: application/json" -X POST http://localhost:8088/responses \
-d '{"input":"Your question here","stream":false}'
```
Example prompts by sample:
| Sample | Example input |
| ------------------------------------ | ---------------------------------------------------------------------------- |
| `agent_with_hosted_mcp` | `What does Microsoft Learn say about managed identities in Azure?` |
| `agent_with_text_search_rag` | `What is Contoso Outdoors' return policy for refunds?` |
| `agents_in_workflow` | `Create a launch strategy for a budget-friendly electric SUV.` |
| `agent_with_local_tools` | `Find me Seattle hotels from 2025-03-15 to 2025-03-18 under $200 per night.` |
| `writer_reviewer_agents_in_workflow` | `Write a slogan for a new affordable electric SUV.` |
## Deploying to Microsoft Foundry
Each sample includes a `Dockerfile` and `agent.yaml` for deployment. For deployment steps, follow the hosted agents guidance in Microsoft Foundry:
- [Hosted agents overview](https://learn.microsoft.com/en-us/azure/ai-foundry/agents/concepts/hosted-agents)
- [Create a hosted agent with CLI](https://learn.microsoft.com/en-us/azure/ai-foundry/agents/concepts/hosted-agents?tabs=cli#create-a-hosted-agent)
- [Create a hosted agent in Visual Studio Code](https://learn.microsoft.com/en-us/azure/foundry/agents/how-to/vs-code-agents-workflow-pro-code?tabs=windows-powershell&pivots=python)
## Troubleshooting
### Missing Azure credentials
If startup fails with authentication errors, run `az login` and verify the selected subscription with `az account show`.
### Preview package install issues
These samples depend on preview packages such as `azure-ai-agentserver-agentframework`. Use `uv pip install --prerelease=allow -r requirements.txt` or `pip install -r requirements.txt`.
### ARM64 container images fail after deployment
If you build images locally on ARM64 hardware such as Apple Silicon, build for `linux/amd64`:
```bash
docker build --platform=linux/amd64 -t image .
```
@@ -0,0 +1,66 @@
# Virtual environments
.venv/
venv/
env/
.python-version
# Environment files with secrets
.env
.env.*
*.local
# Python build artifacts
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg
# Testing
.tox/
.nox/
.coverage
.coverage.*
htmlcov/
.pytest_cache/
.mypy_cache/
# IDE and OS files
.DS_Store
.idea/
.vscode/
*.swp
*.swo
*~
# Foundry config
.foundry/
build-source-*/
# Git
.git/
.gitignore
# Docker
.dockerignore
# Documentation
docs/
*.md
!README.md
LICENSE
@@ -0,0 +1,3 @@
# IMPORTANT: Never commit .env to version control - add it to .gitignore
PROJECT_ENDPOINT=
MODEL_DEPLOYMENT_NAME=
@@ -0,0 +1,16 @@
FROM python:3.14-slim
WORKDIR /app
COPY ./ .
RUN pip install --upgrade pip && \
if [ -f requirements.txt ]; then \
pip install -r requirements.txt; \
else \
echo "No requirements.txt found"; \
fi
EXPOSE 8088
CMD ["python", "main.py"]
@@ -0,0 +1,162 @@
**IMPORTANT!** All samples and other resources made available in this GitHub repository ("samples") are designed to assist in accelerating development of agents, solutions, and agent workflows for various scenarios. Review all provided resources and carefully test output behavior in the context of your use case. AI responses may be inaccurate and AI actions should be monitored with human oversight. Learn more in the transparency documents for [Agent Service](https://learn.microsoft.com/en-us/azure/ai-foundry/responsible-ai/agents/transparency-note) and [Agent Framework](https://github.com/microsoft/agent-framework/blob/main/TRANSPARENCY_FAQ.md).
Agents, solutions, or other output you create may be subject to legal and regulatory requirements, may require licenses, or may not be suitable for all industries, scenarios, or use cases. By using any sample, you are acknowledging that any output created using those samples are solely your responsibility, and that you will comply with all applicable laws, regulations, and relevant safety standards, terms of service, and codes of conduct.
Third-party samples contained in this folder are subject to their own designated terms, and they have not been tested or verified by Microsoft or its affiliates.
Microsoft has no responsibility to you or others with respect to any of these samples or any resulting output.
# What this sample demonstrates
This sample demonstrates a **key advantage of code-based hosted agents**:
- **Local Python tool execution** - Run custom Python functions as agent tools
Code-based agents can execute **any Python code** you write. This sample includes a Seattle Hotel Agent with a `get_available_hotels` tool that searches for available hotels based on check-in/check-out dates and budget preferences.
The agent is hosted using the [Azure AI AgentServer SDK](https://pypi.org/project/azure-ai-agentserver-agentframework/) and can be deployed to Microsoft Foundry using the Azure Developer CLI.
## How It Works
### Local Tools Integration
In [main.py](main.py), the agent uses a local Python function (`get_available_hotels`) that simulates a hotel availability API. This demonstrates how code-based agents can execute custom server-side logic that prompt agents cannot access.
The tool accepts:
- **check_in_date** - Check-in date in YYYY-MM-DD format
- **check_out_date** - Check-out date in YYYY-MM-DD format
- **max_price** - Maximum price per night in USD (optional, defaults to $500)
### Agent Hosting
The agent is hosted using the [Azure AI AgentServer SDK](https://pypi.org/project/azure-ai-agentserver-agentframework/),
which provisions a REST API endpoint compatible with the OpenAI Responses protocol.
### Agent Deployment
The hosted agent can be deployed to Microsoft Foundry using the Azure Developer CLI [ai agent](https://learn.microsoft.com/en-us/azure/ai-foundry/agents/concepts/hosted-agents?view=foundry&tabs=cli#create-a-hosted-agent) extension.
## Running the Agent Locally
### Prerequisites
Before running this sample, ensure you have:
1. **Microsoft Foundry Project**
- Project created in [Microsoft Foundry](https://learn.microsoft.com/en-us/azure/ai-foundry/what-is-foundry?view=foundry#microsoft-foundry-portals)
- Chat model deployed (e.g., `gpt-4o` or `gpt-4.1`)
- Note your project endpoint URL and model deployment name
2. **Azure CLI**
- Installed and authenticated
- Run `az login` and verify with `az account show`
3. **Python 3.10 or higher**
- Verify your version: `python --version`
### Environment Variables
Set the following environment variables (matching `agent.yaml`):
- `PROJECT_ENDPOINT` - Your Microsoft Foundry project endpoint URL (required)
- `MODEL_DEPLOYMENT_NAME` - The deployment name for your chat model (defaults to `gpt-4.1-mini`)
This sample loads environment variables from a local `.env` file if present.
Create a `.env` file in this directory with the following content:
```
PROJECT_ENDPOINT=https://<your-resource>.services.ai.azure.com/api/projects/<your-project>
MODEL_DEPLOYMENT_NAME=gpt-4.1-mini
```
Or set them via PowerShell:
```powershell
# Replace with your actual values
$env:PROJECT_ENDPOINT="https://<your-resource>.services.ai.azure.com/api/projects/<your-project>"
$env:MODEL_DEPLOYMENT_NAME="gpt-4.1-mini"
```
### Running the Sample
**Recommended (`uv`):**
We recommend using [uv](https://docs.astral.sh/uv/) to create and manage the virtual environment for this sample.
```bash
uv venv .venv
uv pip install --prerelease=allow -r requirements.txt
uv run main.py
```
The sample depends on preview packages, so `--prerelease=allow` is required when installing with `uv`.
**Alternative (`venv`):**
If you do not have `uv` installed, you can use Python's built-in `venv` module instead:
**Windows (PowerShell):**
```powershell
python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -r requirements.txt
python main.py
```
**macOS/Linux:**
```bash
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python main.py
```
This will start the hosted agent locally on `http://localhost:8088/`.
### Interacting with the Agent
**PowerShell (Windows):**
```powershell
$body = @{
input = "I need a hotel in Seattle from 2025-03-15 to 2025-03-18, budget under $200 per night"
stream = $false
} | ConvertTo-Json
Invoke-RestMethod -Uri http://localhost:8088/responses -Method Post -Body $body -ContentType "application/json"
```
**Bash/curl (Linux/macOS):**
```bash
curl -sS -H "Content-Type: application/json" -X POST http://localhost:8088/responses \
-d '{"input": "Find me hotels in Seattle for March 20-23, 2025 under $200 per night","stream":false}'
```
The agent will use the `get_available_hotels` tool to search for available hotels matching your criteria.
### Deploying the Agent to Microsoft Foundry
To deploy your agent to Microsoft Foundry, follow the comprehensive deployment guide at https://learn.microsoft.com/en-us/azure/ai-foundry/agents/concepts/hosted-agents?view=foundry&tabs=cli
## Troubleshooting
### Images built on Apple Silicon or other ARM64 machines do not work on our service
We **recommend using `azd` cloud build**, which always builds images with the correct architecture.
If you choose to **build locally**, and your machine is **not `linux/amd64`** (for example, an Apple Silicon Mac), the image will **not be compatible with our service**, causing runtime failures.
**Fix for local builds**
Use this command to build the image locally:
```shell
docker build --platform=linux/amd64 -t image .
```
This forces the image to be built for the required `amd64` architecture.
@@ -0,0 +1,27 @@
# yaml-language-server: $schema=https://raw.githubusercontent.com/microsoft/AgentSchema/refs/heads/main/schemas/v1.0/ContainerAgent.yaml
kind: hosted
name: agent-with-local-tools
# Brief description of what this agent does
description: >
A travel assistant agent that helps users find hotels in Seattle.
Demonstrates local Python tool execution - a key advantage of code-based
hosted agents over prompt agents.
metadata:
# Categorization tags for organizing and discovering agents
authors:
- Microsoft
tags:
- Azure AI AgentServer
- Microsoft Agent Framework
- Local Tools
- Travel Assistant
- Hotel Search
protocols:
- protocol: responses
version: v1
environment_variables:
- name: PROJECT_ENDPOINT
value: ${PROJECT_ENDPOINT}
- name: MODEL_DEPLOYMENT_NAME
value: ${MODEL_DEPLOYMENT_NAME}
@@ -0,0 +1,158 @@
# Copyright (c) Microsoft. All rights reserved.
"""
Seattle Hotel Agent - A simple agent with a tool to find hotels in Seattle.
Uses Microsoft Agent Framework with Azure AI Foundry.
Ready for deployment to Foundry Hosted Agent service.
"""
import asyncio
import os
from datetime import datetime
from typing import Annotated
from agent_framework.azure import AzureOpenAIResponsesClient
from azure.ai.agentserver.agentframework import from_agent_framework
from azure.identity.aio import AzureCliCredential, ManagedIdentityCredential
from dotenv import load_dotenv
load_dotenv(override=True)
# Configure these for your Foundry project
# Read the explicit variables present in the .env file
PROJECT_ENDPOINT = os.getenv(
"PROJECT_ENDPOINT"
) # e.g., "https://<project>.services.ai.azure.com"
MODEL_DEPLOYMENT_NAME = os.getenv(
"MODEL_DEPLOYMENT_NAME", "gpt-4.1-mini"
) # Your model deployment name e.g., "gpt-4.1-mini"
# Simulated hotel data for Seattle
SEATTLE_HOTELS = [
{
"name": "Contoso Suites",
"price_per_night": 189,
"rating": 4.5,
"location": "Downtown",
},
{
"name": "Fabrikam Residences",
"price_per_night": 159,
"rating": 4.2,
"location": "Pike Place Market",
},
{
"name": "Alpine Ski House",
"price_per_night": 249,
"rating": 4.7,
"location": "Seattle Center",
},
{
"name": "Margie's Travel Lodge",
"price_per_night": 219,
"rating": 4.4,
"location": "Waterfront",
},
{
"name": "Northwind Inn",
"price_per_night": 139,
"rating": 4.0,
"location": "Capitol Hill",
},
{
"name": "Relecloud Hotel",
"price_per_night": 99,
"rating": 3.8,
"location": "University District",
},
]
def get_available_hotels(
check_in_date: Annotated[str, "Check-in date in YYYY-MM-DD format"],
check_out_date: Annotated[str, "Check-out date in YYYY-MM-DD format"],
max_price: Annotated[int, "Maximum price per night in USD (optional)"] = 500,
) -> str:
"""
Get available hotels in Seattle for the specified dates.
This simulates a call to a fake hotel availability API.
"""
try:
# Parse dates
check_in = datetime.strptime(check_in_date, "%Y-%m-%d")
check_out = datetime.strptime(check_out_date, "%Y-%m-%d")
# Validate dates
if check_out <= check_in:
return "Error: Check-out date must be after check-in date."
nights = (check_out - check_in).days
# Filter hotels by price
available_hotels = [
hotel for hotel in SEATTLE_HOTELS if hotel["price_per_night"] <= max_price
]
if not available_hotels:
return (
f"No hotels found in Seattle within your budget of ${max_price}/night."
)
# Build response
result = f"Available hotels in Seattle from {check_in_date} to {check_out_date} ({nights} nights):\n\n"
for hotel in available_hotels:
total_cost = hotel["price_per_night"] * nights
result += f"**{hotel['name']}**\n"
result += f" Location: {hotel['location']}\n"
result += f" Rating: {hotel['rating']}/5\n"
result += f" ${hotel['price_per_night']}/night (Total: ${total_cost})\n\n"
return result
except ValueError as e:
return f"Error parsing dates. Please use YYYY-MM-DD format. Details: {str(e)}"
def get_credential():
"""Will use Managed Identity when running in Azure, otherwise falls back to Azure CLI Credential."""
return (
ManagedIdentityCredential()
if os.getenv("MSI_ENDPOINT")
else AzureCliCredential()
)
async def main():
"""Main function to run the agent as a web server."""
async with get_credential() as credential:
client = AzureOpenAIResponsesClient(
project_endpoint=PROJECT_ENDPOINT,
deployment_name=MODEL_DEPLOYMENT_NAME,
credential=credential,
)
agent = client.as_agent(
name="SeattleHotelAgent",
instructions="""You are a helpful travel assistant specializing in finding hotels in Seattle, Washington.
When a user asks about hotels in Seattle:
1. Ask for their check-in and check-out dates if not provided
2. Ask about their budget preferences if not mentioned
3. Use the get_available_hotels tool to find available options
4. Present the results in a friendly, informative way
5. Offer to help with additional questions about the hotels or Seattle
Be conversational and helpful. If users ask about things outside of Seattle hotels,
politely let them know you specialize in Seattle hotel recommendations.""",
tools=[get_available_hotels],
)
print("Seattle Hotel Agent Server running on http://localhost:8088")
server = from_agent_framework(agent)
await server.run_async()
if __name__ == "__main__":
asyncio.run(main())
@@ -0,0 +1,2 @@
azure-ai-agentserver-agentframework==1.0.0b16
agent-framework-azure-ai
@@ -0,0 +1,51 @@
# Build artifacts
bin/
obj/
# IDE and editor files
.vs/
.vscode/
*.user
*.suo
.foundry/
# Source control
.git/
# Documentation
README.md
# Ignore files
.gitignore
.dockerignore
# Logs
*.log
# Temporary files
*.tmp
*.temp
# OS files
.DS_Store
Thumbs.db
# Package manager directories
node_modules/
packages/
# Test results
TestResults/
*.trx
# Coverage reports
coverage/
*.coverage
*.coveragexml
# Local development config
appsettings.Development.json
.env
.venv/
__pycache__/
@@ -0,0 +1,3 @@
# IMPORTANT: Never commit .env to version control - add it to .gitignore
PROJECT_ENDPOINT=
MODEL_DEPLOYMENT_NAME=
@@ -0,0 +1,16 @@
FROM python:3.14-slim
WORKDIR /app
COPY ./ .
RUN pip install --upgrade pip && \
if [ -f requirements.txt ]; then \
pip install -r requirements.txt; \
else \
echo "No requirements.txt found"; \
fi
EXPOSE 8088
CMD ["python", "main.py"]
@@ -0,0 +1,157 @@
**IMPORTANT!** All samples and other resources made available in this GitHub repository ("samples") are designed to assist in accelerating development of agents, solutions, and agent workflows for various scenarios. Review all provided resources and carefully test output behavior in the context of your use case. AI responses may be inaccurate and AI actions should be monitored with human oversight. Learn more in the transparency documents for [Agent Service](https://learn.microsoft.com/en-us/azure/ai-foundry/responsible-ai/agents/transparency-note) and [Agent Framework](https://github.com/microsoft/agent-framework/blob/main/TRANSPARENCY_FAQ.md).
Agents, solutions, or other output you create may be subject to legal and regulatory requirements, may require licenses, or may not be suitable for all industries, scenarios, or use cases. By using any sample, you are acknowledging that any output created using those samples are solely your responsibility, and that you will comply with all applicable laws, regulations, and relevant safety standards, terms of service, and codes of conduct.
Third-party samples contained in this folder are subject to their own designated terms, and they have not been tested or verified by Microsoft or its affiliates.
Microsoft has no responsibility to you or others with respect to any of these samples or any resulting output.
# What this sample demonstrates
This sample demonstrates a **key advantage of code-based hosted agents**:
- **Agents in Workflows** - Use AI agents as executors within a workflow pipeline
Code-based agents can execute **any Python code** you write. This sample includes a multi-agent workflow where Writer and Reviewer agents collaborate to draft content and provide review feedback.
The agent is hosted using the [Azure AI AgentServer SDK](https://pypi.org/project/azure-ai-agentserver-agentframework/) and can be deployed to Microsoft Foundry using the Azure Developer CLI.
## How It Works
### Agents in Workflows
This sample demonstrates the integration of AI agents within a workflow pipeline. The workflow operates as follows:
1. **Writer Agent** - Drafts content
2. **Reviewer Agent** - Reviews the draft and provides concise, actionable feedback
### Agent Hosting
The agent workflow is hosted using the [Azure AI AgentServer SDK](https://pypi.org/project/azure-ai-agentserver-agentframework/),
which provisions a REST API endpoint compatible with the OpenAI Responses protocol.
### Agent Deployment
The hosted agent workflow can be deployed to Microsoft Foundry using the Azure Developer CLI [ai agent](https://learn.microsoft.com/en-us/azure/ai-foundry/agents/concepts/hosted-agents?view=foundry&tabs=cli#create-a-hosted-agent) extension.
## Running the Agent Locally
### Prerequisites
Before running this sample, ensure you have:
1. **Microsoft Foundry Project**
- Project created in [Microsoft Foundry](https://learn.microsoft.com/en-us/azure/ai-foundry/what-is-foundry?view=foundry#microsoft-foundry-portals)
- Chat model deployed (e.g., `gpt-4o` or `gpt-4.1`)
- Note your project endpoint URL and model deployment name
2. **Azure CLI**
- Installed and authenticated
- Run `az login` and verify with `az account show`
3. **Python 3.10 or higher**
- Verify your version: `python --version`
### Environment Variables
Set the following environment variables (matching `agent.yaml`):
- `PROJECT_ENDPOINT` - Your Microsoft Foundry project endpoint URL (required)
- `MODEL_DEPLOYMENT_NAME` - The deployment name for your chat model (defaults to `gpt-4.1-mini`)
This sample loads environment variables from a local `.env` file if present.
Create a `.env` file in this directory with the following content:
```
PROJECT_ENDPOINT=https://<your-resource>.services.ai.azure.com/api/projects/<your-project>
MODEL_DEPLOYMENT_NAME=gpt-4.1-mini
```
Or set them via PowerShell:
```powershell
# Replace with your actual values
$env:PROJECT_ENDPOINT="https://<your-resource>.services.ai.azure.com/api/projects/<your-project>"
$env:MODEL_DEPLOYMENT_NAME="gpt-4.1-mini"
```
### Running the Sample
**Recommended (`uv`):**
We recommend using [uv](https://docs.astral.sh/uv/) to create and manage the virtual environment for this sample.
```bash
uv venv .venv
uv pip install --prerelease=allow -r requirements.txt
uv run main.py
```
The sample depends on preview packages, so `--prerelease=allow` is required when installing with `uv`.
**Alternative (`venv`):**
If you do not have `uv` installed, you can use Python's built-in `venv` module instead:
**Windows (PowerShell):**
```powershell
python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -r requirements.txt
python main.py
```
**macOS/Linux:**
```bash
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python main.py
```
This will start the hosted agent locally on `http://localhost:8088/`.
### Interacting with the Agent
**PowerShell (Windows):**
```powershell
$body = @{
input = "Create a slogan for a new electric SUV that is affordable and fun to drive."
stream = $false
} | ConvertTo-Json
Invoke-RestMethod -Uri http://localhost:8088/responses -Method Post -Body $body -ContentType "application/json"
```
**Bash/curl (Linux/macOS):**
```bash
curl -sS -H "Content-Type: application/json" -X POST http://localhost:8088/responses \
-d '{"input": "Create a slogan for a new electric SUV that is affordable and fun to drive.","stream":false}'
```
### Deploying the Agent to Microsoft Foundry
To deploy your agent to Microsoft Foundry, follow the comprehensive deployment guide at https://learn.microsoft.com/en-us/azure/ai-foundry/agents/concepts/hosted-agents?view=foundry&tabs=cli
## Troubleshooting
### Images built on Apple Silicon or other ARM64 machines do not work on our service
We **recommend using `azd` cloud build**, which always builds images with the correct architecture.
If you choose to **build locally**, and your machine is **not `linux/amd64`** (for example, an Apple Silicon Mac), the image will **not be compatible with our service**, causing runtime failures.
**Fix for local builds**
Use this command to build the image locally:
```shell
docker build --platform=linux/amd64 -t image .
```
This forces the image to be built for the required `amd64` architecture.
@@ -0,0 +1,24 @@
# yaml-language-server: $schema=https://raw.githubusercontent.com/microsoft/AgentSchema/refs/heads/main/schemas/v1.0/ContainerAgent.yaml
kind: hosted
name: writer-reviewer-agents-in-workflow
description: >
A multi-agent workflow featuring a Writer and Reviewer that collaborate
to create and refine content.
metadata:
authors:
- Microsoft
tags:
- Azure AI AgentServer
- Microsoft Agent Framework
- Multi-Agent Workflow
- Writer-Reviewer
- Content Creation
protocols:
- protocol: responses
version: v1
environment_variables:
- name: PROJECT_ENDPOINT
value: ${PROJECT_ENDPOINT}
- name: MODEL_DEPLOYMENT_NAME
value: ${MODEL_DEPLOYMENT_NAME}
@@ -0,0 +1,73 @@
# Copyright (c) Microsoft. All rights reserved.
import asyncio
import os
from contextlib import asynccontextmanager
from agent_framework import WorkflowBuilder
from agent_framework.azure import AzureOpenAIResponsesClient
from azure.ai.agentserver.agentframework import from_agent_framework
from azure.identity.aio import AzureCliCredential, ManagedIdentityCredential
from dotenv import load_dotenv
load_dotenv(override=True)
# Configure these for your Foundry project
# Read the explicit variables present in the .env file
PROJECT_ENDPOINT = os.getenv(
"PROJECT_ENDPOINT"
) # e.g., "https://<project>.services.ai.azure.com/api/projects/<project-name>"
MODEL_DEPLOYMENT_NAME = os.getenv(
"MODEL_DEPLOYMENT_NAME", "gpt-4.1-mini"
) # Your model deployment name e.g., "gpt-4.1-mini"
def get_credential():
"""Will use Managed Identity when running in Azure, otherwise falls back to Azure CLI Credential."""
return (
ManagedIdentityCredential()
if os.getenv("MSI_ENDPOINT")
else AzureCliCredential()
)
@asynccontextmanager
async def create_agents():
async with get_credential() as credential:
client = AzureOpenAIResponsesClient(
project_endpoint=PROJECT_ENDPOINT,
deployment_name=MODEL_DEPLOYMENT_NAME,
credential=credential,
)
writer = client.as_agent(
name="Writer",
instructions="You are an excellent content writer. You create new content and edit contents based on the feedback.",
)
reviewer = client.as_agent(
name="Reviewer",
instructions="You are an excellent content reviewer. Provide actionable feedback to the writer about the provided content in the most concise manner possible.",
)
yield writer, reviewer
def create_workflow(writer, reviewer):
workflow = WorkflowBuilder(start_executor=writer).add_edge(writer, reviewer).build()
return workflow.as_agent()
async def main() -> None:
"""
The writer and reviewer multi-agent workflow.
Environment variables required:
- PROJECT_ENDPOINT: Your Microsoft Foundry project endpoint
- MODEL_DEPLOYMENT_NAME: Your Microsoft Foundry model deployment name
"""
async with create_agents() as (writer, reviewer):
agent = create_workflow(writer, reviewer)
await from_agent_framework(agent).run_async()
if __name__ == "__main__":
asyncio.run(main())
@@ -0,0 +1,2 @@
azure-ai-agentserver-agentframework==1.0.0b16
agent-framework-azure-ai