azure-ai-projects 2.0.1

Microsoft Corporation Azure AI Projects Client Library for Python

Azure AI Projects client library for Python

The AI Projects client library (in preview) is part of the Microsoft Foundry SDK, and provides easy access to resources in your Microsoft Foundry Project. Use it to:

• Create and run Agents using methods on the .agents client property.
• Enhance Agents with specialized tools:
  • Agent-to-Agent (A2A) (Preview)
  • Azure AI Search
  • Azure Functions
  • Bing Custom Search (Preview)
  • Bing Grounding
  • Browser Automation (Preview)
  • Code Interpreter
  • Computer Use (Preview)
  • File Search
  • Function Tool
  • Image Generation
  • Memory Search (Preview)
  • Microsoft Fabric (Preview)
  • Microsoft SharePoint (Preview)
  • Model Context Protocol (MCP)
  • OpenAPI
  • Web Search
  • Web Search (Preview)
• Get an OpenAI client using .get_openai_client() method to run Responses, Conversations, Evaluations and Fine-Tuning operations with your Agent.
• Manage memory stores (preview) for Agent conversations, using .beta.memory_stores operations.
• Explore additional evaluation tools (some in preview) to assess the performance of your generative AI application, using .evaluation_rules, .beta.evaluation_taxonomies, .beta.evaluators, .beta.insights, and .beta.schedules operations.
• Run Red Team scans (preview) to identify risks associated with your generative AI application, using .beta.red_teams operations.
• Fine tune AI Models on your data.
• Enumerate AI Models deployed to your Foundry Project using .deployments operations.
• Enumerate connected Azure resources in your Foundry project using .connections operations.
• Upload documents and create Datasets to reference them using .datasets operations.
• Create and enumerate Search Indexes using .indexes operations.

The client library uses version v1 of the Microsoft Foundry data plane REST APIs.

Product documentation | Samples | API reference | Package (PyPI) | SDK source code | Release history

Reporting issues

To report an issue with the client library, or request additional features, please open a GitHub issue here. Mention the package name "azure-ai-projects" in the title or content.

Getting started

Prerequisite

• Python 3.9 or later.
• An Azure subscription.
• A project in Microsoft Foundry.
• A Foundry project endpoint URL of the form https://your-ai-services-account-name.services.ai.azure.com/api/projects/your-project-name. It can be found in your Microsoft Foundry Project home page. Below we will assume the environment variable AZURE_AI_PROJECT_ENDPOINT was defined to hold this value.
• An Entra ID token for authentication. Your application needs an object that implements the TokenCredential interface. Code samples here use DefaultAzureCredential. To get that working, you will need:
  • An appropriate role assignment. See Role-based access control in Microsoft Foundry portal. Role assignment can be done via the "Access Control (IAM)" tab of your Azure AI Project resource in the Azure portal.
  • Azure CLI installed.
  • You are logged into your Azure account by running az login.

Install the package

pip install azure-ai-projects

Verify that you have version 2.0.0 or above installed by running:

pip show azure-ai-projects

Key concepts

Create and authenticate the client with Entra ID

Entra ID is the only authentication method supported at the moment by the client.

To construct a synchronous client using a context manager:

import os
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential

with (
    DefaultAzureCredential() as credential,
    AIProjectClient(endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"], credential=credential) as project_client,
):

To construct an asynchronous client, install the additional package aiohttp:

pip install aiohttp

and run:

import os
import asyncio
from azure.ai.projects.aio import AIProjectClient
from azure.identity.aio import DefaultAzureCredential

async with (
    DefaultAzureCredential() as credential,
    AIProjectClient(endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"], credential=credential) as project_client,
):

Examples

Performing Responses operations using OpenAI client

Your Microsoft Foundry project may have one or more AI models deployed. These could be OpenAI models, Microsoft models, or models from other providers. Use the code below to get an authenticated OpenAI client from the openai package, and execute an example multi-turn "Responses" calls.

The code below assumes the environment variable AZURE_AI_MODEL_DEPLOYMENT_NAME is defined. It's the deployment name of an AI model in your Foundry Project. See "Build" menu, under "Models" (First column of the "Deployments" table).

with project_client.get_openai_client() as openai_client:
    response = openai_client.responses.create(
        model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
        input="What is the size of France in square miles?",
    )
    print(f"Response output: {response.output_text}")

    response = openai_client.responses.create(
        model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
        input="And what is the capital city?",
        previous_response_id=response.id,
    )
    print(f"Response output: {response.output_text}")

See the "responses" folder in the package samples for additional samples, including streaming responses.

Performing Agent operations

The .agents property on the AIProjectClient gives you access to all Agent operations. Agents use an extension of the OpenAI Responses protocol, so you will need to get an OpenAI client to do Agent operations, as shown in the example below.

The code below assumes environment variable AZURE_AI_MODEL_DEPLOYMENT_NAME is defined. It's the deployment name of an AI model in your Foundry Project. See "Build" menu, under "Models" (First column of the "Deployments" table).

See the "agents" folder in the package samples for an extensive set of samples, including streaming, tool usage and memory store usage.

with project_client.get_openai_client() as openai_client:
    agent = project_client.agents.create_version(
        agent_name="MyAgent",
        definition=PromptAgentDefinition(
            model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
            instructions="You are a helpful assistant that answers general questions",
        ),
    )
    print(f"Agent created (id: {agent.id}, name: {agent.name}, version: {agent.version})")

    conversation = openai_client.conversations.create(
        items=[{"type": "message", "role": "user", "content": "What is the size of France in square miles?"}],
    )
    print(f"Created conversation with initial user message (id: {conversation.id})")

    response = openai_client.responses.create(
        conversation=conversation.id,
        extra_body={"agent_reference": {"name": agent.name, "type": "agent_reference"}},
    )
    print(f"Response output: {response.output_text}")

    openai_client.conversations.items.create(
        conversation_id=conversation.id,
        items=[{"type": "message", "role": "user", "content": "And what is the capital city?"}],
    )
    print(f"Added a second user message to the conversation")

    response = openai_client.responses.create(
        conversation=conversation.id,
        extra_body={"agent_reference": {"name": agent.name, "type": "agent_reference"}},
    )
    print(f"Response output: {response.output_text}")

    openai_client.conversations.delete(conversation_id=conversation.id)
    print("Conversation deleted")

project_client.agents.delete_version(agent_name=agent.name, agent_version=agent.version)
print("Agent deleted")

Using Agent tools

Agents can be enhanced with specialized tools for various capabilities. For complete working examples of all tools, see the \agents\tools folder under the Samples folder.

In the description below, tools are organized by their Foundry connection requirements: "Built-in Tools" (which do not require a Foundry connection) and "Connection-based Tools" (which require a Foundry connection).

Built-in Tools

These tools work immediately without requiring external connections.

---

Code Interpreter (documentation)

Write and run Python code in a sandboxed environment, process files and work with diverse data formats. See also OpenAI Documentation.

Basic tool declaration (no input files):

tool = CodeInterpreterTool()

See the basic sample in file \agents\tools\sample_agent_code_interpreter.py in the Samples folder.

After calling responses.create(), you can extract the code behind the scene from the code_interpreter_call output item:

code = next((output.code for output in response.output if output.type == "code_interpreter_call"), "")
print(f"Code Interpreter code:")
print(code)

If you want to upload an input file and download generated output files:

# Load the CSV file to be processed
asset_file_path = os.path.abspath(
    os.path.join(os.path.dirname(__file__), "../assets/synthetic_500_quarterly_results.csv")
)

# Upload the CSV file for the code interpreter
file = openai_client.files.create(purpose="assistants", file=open(asset_file_path, "rb"))
tool = CodeInterpreterTool(container=AutoCodeInterpreterToolParam(file_ids=[file.id]))

After calling responses.create(), check for generated files in response annotations (type container_file_citation) and download them using openai_client.containers.files.content.retrieve().

See full sample file \agents\tools\sample_agent_code_interpreter_with_files.py in the Samples folder.

---

File Search (documentation)

Built-in RAG (Retrieval-Augmented Generation) tool to process and search through documents using vector stores for knowledge retrieval. See also OpenAI Documentation.

# Create vector store for file search
vector_store = openai_client.vector_stores.create(name="ProductInfoStore")
print(f"Vector store created (id: {vector_store.id})")

# Load the file to be indexed for search
asset_file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../assets/product_info.md"))

# Upload file to vector store
file = openai_client.vector_stores.files.upload_and_poll(
    vector_store_id=vector_store.id, file=open(asset_file_path, "rb")
)
print(f"File uploaded to vector store (id: {file.id})")

tool = FileSearchTool(vector_store_ids=[vector_store.id])

See the full sample in file \agents\tools\sample_agent_file_search.py in the Samples folder.

---

Image Generation (documentation)

Generate images based on text prompts with customizable resolution, quality, and style settings:

tool = ImageGenTool(
    model=image_generation_model,  # Model such as "gpt-image-1"
    quality="low",
    size="1024x1024",
)

After calling responses.create(), you can download file using the returned response:

image_data = [output.result for output in response.output if output.type == "image_generation_call"]
if image_data and image_data[0]:
    print("Downloading generated image...")
    filename = "microsoft.png"
    file_path = os.path.join(tempfile.gettempdir(), filename)

    with open(file_path, "wb") as f:
        f.write(base64.b64decode(image_data[0]))

See the full sample in file \agents\tools\sample_agent_image_generation.py in the Samples folder.

---

Web Search / Web Search (Preview) (documentation)

Discover up-to-date web content with the GA Web Search tool or try the Web Search Preview tool for the latest enhancements. Guidance on when to use each option can be found here.

Warning: Web Search tool uses Grounding with Bing, which has additional costs and terms: terms of use and privacy statement. Customer data will flow outside the Azure compliance boundary. See the note titled Important on Web search tool (preview) page.

tool = WebSearchTool(user_location=WebSearchApproximateLocation(country="GB", city="London", region="London"))

See the full sample in file \agents\tools\sample_agent_web_search.py in the Samples folder.

tool = WebSearchPreviewTool(user_location=ApproximateLocation(country="GB", city="London", region="London"))

See the full sample in file \agents\tools\sample_agent_web_search_preview.py in the Samples folder.

Use the GA Web Search tool with a Bing Custom Search connection to scope results to your custom search instance:

tool = WebSearchTool(
    custom_search_configuration=WebSearchConfiguration(
        project_connection_id=os.environ["BING_CUSTOM_SEARCH_PROJECT_CONNECTION_ID"],
        instance_name=os.environ["BING_CUSTOM_SEARCH_INSTANCE_NAME"],
    )
)

See the full sample in file \agents\tools\sample_agent_web_search_with_custom_search.py in the Samples folder.

---

Computer Use (Preview) (documentation)

Enable agents to interact directly with computer systems for task automation and system operations:

tool = ComputerUsePreviewTool(display_width=1026, display_height=769, environment="windows")

After calling responses.create(), process the response in an interaction loop. Handle computer_call output items and provide screenshots as computer_call_output with computer_screenshot type to continue the interaction.

See the full sample in file \agents\tools\sample_agent_computer_use.py in the Samples folder.

---

Model Context Protocol (MCP) (documentation)

Integrate MCP servers to extend agent capabilities with standardized tools and resources. See also OpenAI Documentation.

mcp_tool = MCPTool(
    server_label="api-specs",
    server_url="https://gitmcp.io/Azure/azure-rest-api-specs",
    require_approval="always",
)

After calling responses.create(), check for mcp_approval_request items in the response output. Send back McpApprovalResponse with your approval decision to allow the agent to continue its work.

See the full sample in file \agents\tools\sample_agent_mcp.py in the Samples folder.

---

OpenAPI (documentation)

Call external APIs defined by OpenAPI specifications without additional client-side code.

with open(weather_asset_file_path, "r") as f:
    openapi_weather = cast(dict[str, Any], jsonref.loads(f.read()))

tool = OpenApiTool(
    openapi=OpenApiFunctionDefinition(
        name="get_weather",
        spec=openapi_weather,
        description="Retrieve weather information for a location.",
        auth=OpenApiAnonymousAuthDetails(),
    )
)

See the full sample in file \agents\tools\sample_agent_openapi.py in the Samples folder.

---

Function Tool (documentation)

Define custom functions that allow agents to interact with external APIs, databases, or application logic. See also OpenAI Documentation.

tool = FunctionTool(
    name="get_horoscope",
    parameters={
        "type": "object",
        "properties": {
            "sign": {
                "type": "string",
                "description": "An astrological sign like Taurus or Aquarius",
            },
        },
        "required": ["sign"],
        "additionalProperties": False,
    },
    description="Get today's horoscope for an astrological sign.",
    strict=True,
)

After calling responses.create(), process function_call items from response output, execute your function logic with the provided arguments, and send back FunctionCallOutput with the results.

See the full sample in file \agents\tools\sample_agent_function_tool.py in the Samples folder.

---

Azure Functions

Integrate Azure Functions with agents to extend capabilities via serverless compute. Functions are invoked through Azure Storage Queue triggers, allowing asynchronous execution of custom logic.

tool = AzureFunctionTool(
    azure_function=AzureFunctionDefinition(
        input_binding=AzureFunctionBinding(
            storage_queue=AzureFunctionStorageQueue(
                queue_name=os.environ["STORAGE_INPUT_QUEUE_NAME"],
                queue_service_endpoint=os.environ["STORAGE_QUEUE_SERVICE_ENDPOINT"],
            )
        ),
        output_binding=AzureFunctionBinding(
            storage_queue=AzureFunctionStorageQueue(
                queue_name=os.environ["STORAGE_OUTPUT_QUEUE_NAME"],
                queue_service_endpoint=os.environ["STORAGE_QUEUE_SERVICE_ENDPOINT"],
            )
        ),
        function=AzureFunctionDefinitionFunction(
            name="queue_trigger",
            description="Get weather for a given location",
            parameters={
                "type": "object",
                "properties": {"location": {"type": "string", "description": "location to determine weather for"}},
            },
        ),
    )
)

After calling responses.create(), the agent enqueues function arguments to the input queue. Your Azure Function processes the request and returns results via the output queue.

See the full sample in file \agents\tools\sample_agent_azure_function.py and the Azure Function implementation in \agents\tools\get_weather_func_app.py in the Samples folder.

---

Memory Search Tool (Preview) (documentation)

The Memory Store Tool adds Memory to an Agent, allowing the Agent's AI model to search for past information related to the current user prompt.

# Set scope to associate the memories with
# You can also use "{{$userId}}" to take the oid of the request authentication header
scope = "user_123"

tool = MemorySearchPreviewTool(
    memory_store_name=memory_store.name,
    scope=scope,
    update_delay=1,  # Wait 1 second of inactivity before updating memories
    # In a real application, set this to a higher value like 300 (5 minutes, default)
)

See the full sample in file \agents\tools\sample_agent_memory_search.py in the Samples folder showing how to create an Agent with a memory store, and use it in multiple conversations.

See also other samples in the folder \memories under Samples folder, showing how to manage memory stores.

---

Connection-Based Tools

These tools require configuring connections in your Microsoft Foundry project and use project_connection_id.

Azure AI Search (documentation)

Integrate with Azure AI Search indexes for powerful knowledge retrieval and semantic search capabilities:

tool = AzureAISearchTool(
    azure_ai_search=AzureAISearchToolResource(
        indexes=[
            AISearchIndexResource(
                project_connection_id=os.environ["AI_SEARCH_PROJECT_CONNECTION_ID"],
                index_name=os.environ["AI_SEARCH_INDEX_NAME"],
                query_type=AzureAISearchQueryType.SIMPLE,
            ),
        ]
    )
)

See the full sample in file \agents\tools\sample_agent_ai_search.py in the Samples folder.

---

Bing Grounding (documentation)

Warning: Grounding with Bing Search tool uses Grounding with Bing, which has additional costs and terms: terms of use and privacy statement. Customer data will flow outside the Azure compliance boundary. See the note titled Important on the Grounding agents with Bing Search tools page.

Ground agent responses with real-time web search results from Bing to provide up-to-date information:

tool = BingGroundingTool(
    bing_grounding=BingGroundingSearchToolParameters(
        search_configurations=[
            BingGroundingSearchConfiguration(project_connection_id=os.environ["BING_PROJECT_CONNECTION_ID"])
        ]
    )
)

See the full sample in file \agents\tools\sample_agent_bing_grounding.py in the Samples folder.

---

Bing Custom Search (Preview) (documentation)

Warning: Grounding with Bing Custom Search tool uses Grounding with Bing, which has additional costs and terms: terms of use and privacy statement. Customer data will flow outside the Azure compliance boundary. See the note titled Important on the Web search tool (preview) page.

Use custom-configured Bing search instances for domain-specific or filtered web search results:

tool = BingCustomSearchPreviewTool(
    bing_custom_search_preview=BingCustomSearchToolParameters(
        search_configurations=[
            BingCustomSearchConfiguration(
                project_connection_id=os.environ["BING_CUSTOM_SEARCH_PROJECT_CONNECTION_ID"],
                instance_name=os.environ["BING_CUSTOM_SEARCH_INSTANCE_NAME"],
            )
        ]
    )
)

See the full sample in file \agents\tools\sample_agent_bing_custom_search.py in the Samples folder.

---

Microsoft Fabric (Preview) (documentation)

Connect to and query Microsoft Fabric:

tool = MicrosoftFabricPreviewTool(
    fabric_dataagent_preview=FabricDataAgentToolParameters(
        project_connections=[
            ToolProjectConnection(project_connection_id=os.environ["FABRIC_PROJECT_CONNECTION_ID"])
        ]
    )
)

See the full sample in file \agents\tools\sample_agent_fabric.py in the Samples folder.

---

Microsoft SharePoint (Preview) (documentation)

Access and search SharePoint documents, lists, and sites for enterprise knowledge integration:

tool = SharepointPreviewTool(
    sharepoint_grounding_preview=SharepointGroundingToolParameters(
        project_connections=[
            ToolProjectConnection(project_connection_id=os.environ["SHAREPOINT_PROJECT_CONNECTION_ID"])
        ]
    )
)

See the full sample in file \agents\tools\sample_agent_sharepoint.py in the Samples folder.

---

Browser Automation (Preview) (documentation)

Automate browser interactions for web scraping, testing, and interaction with web applications:

tool = BrowserAutomationPreviewTool(
    browser_automation_preview=BrowserAutomationToolParameters(
        connection=BrowserAutomationToolConnectionParameters(
            project_connection_id=os.environ["BROWSER_AUTOMATION_PROJECT_CONNECTION_ID"],
        )
    )
)

See the full sample in file \agents\tools\sample_agent_browser_automation.py in the Samples folder.

---

MCP with Project Connection (documentation)

MCP integration using project-specific connections for accessing connected MCP servers:

tool = MCPTool(
    server_label="api-specs",
    server_url="https://api.githubcopilot.com/mcp",
    require_approval="always",
    project_connection_id=os.environ["MCP_PROJECT_CONNECTION_ID"],
)

See the full sample in file \agents\tools\sample_agent_mcp_with_project_connection.py in the Samples folder.

---

Agent-to-Agent (A2A) (Preview) (documentation)

Enable multi-agent collaboration where agents can communicate and delegate tasks to other specialized agents:

tool = A2APreviewTool(
    project_connection_id=os.environ["A2A_PROJECT_CONNECTION_ID"],
)
# If the connection is missing target, we need to set the A2A endpoint URL.
if os.environ.get("A2A_ENDPOINT"):
    tool.base_url = os.environ["A2A_ENDPOINT"]

See the full sample in file \agents\tools\sample_agent_to_agent.py in the Samples folder.

---

OpenAPI with Project Connection (documentation)

Call external APIs defined by OpenAPI specifications using project connection authentication:

with open(tripadvisor_asset_file_path, "r", encoding="utf-8") as f:
    openapi_tripadvisor = cast(dict[str, Any], jsonref.loads(f.read()))

tool = OpenApiTool(
    openapi=OpenApiFunctionDefinition(
        name="tripadvisor",
        spec=openapi_tripadvisor,
        description="Trip Advisor API to get travel information",
        auth=OpenApiProjectConnectionAuthDetails(
            security_scheme=OpenApiProjectConnectionSecurityScheme(
                project_connection_id=os.environ["OPENAPI_PROJECT_CONNECTION_ID"]
            )
        ),
    )
)

See the full sample in file \agents\tools\sample_agent_openapi_with_project_connection.py in the Samples folder.

Evaluation

Evaluation in Azure AI Project client library provides quantitative, AI-assisted quality and safety metrics to asses performance and Evaluate LLM Models, GenAI Application and Agents. Metrics are defined as evaluators. Built-in or custom evaluators can provide comprehensive evaluation insights.

The code below shows some evaluation operations. Full list of sample can be found under "evaluation" folder in the package samples

with (
    DefaultAzureCredential() as credential,
    AIProjectClient(endpoint=endpoint, credential=credential) as project_client,
    project_client.get_openai_client() as openai_client,
):
    agent = project_client.agents.create_version(
        agent_name=os.environ["AZURE_AI_AGENT_NAME"],
        definition=PromptAgentDefinition(
            model=model_deployment_name,
            instructions="You are a helpful assistant that answers general questions",
        ),
    )
    print(f"Agent created (id: {agent.id}, name: {agent.name}, version: {agent.version})")

    data_source_config = DataSourceConfigCustom(
        type="custom",
        item_schema={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]},
        include_sample_schema=True,
    )
    # Notes: for data_mapping:
    # sample.output_text is the string output of the agent
    # sample.output_items is the structured JSON output of the agent, including tool calls information
    testing_criteria = [
        {
            "type": "azure_ai_evaluator",
            "name": "violence_detection",
            "evaluator_name": "builtin.violence",
            "data_mapping": {"query": "{{item.query}}", "response": "{{sample.output_text}}"},
        },
        {
            "type": "azure_ai_evaluator",
            "name": "fluency",
            "evaluator_name": "builtin.fluency",
            "initialization_parameters": {"deployment_name": f"{model_deployment_name}"},
            "data_mapping": {"query": "{{item.query}}", "response": "{{sample.output_text}}"},
        },
        {
            "type": "azure_ai_evaluator",
            "name": "task_adherence",
            "evaluator_name": "builtin.task_adherence",
            "initialization_parameters": {"deployment_name": f"{model_deployment_name}"},
            "data_mapping": {"query": "{{item.query}}", "response": "{{sample.output_items}}"},
        },
    ]
    eval_object = openai_client.evals.create(
        name="Agent Evaluation",
        data_source_config=data_source_config,
        testing_criteria=testing_criteria,  # type: ignore
    )
    print(f"Evaluation created (id: {eval_object.id}, name: {eval_object.name})")

    data_source = {
        "type": "azure_ai_target_completions",
        "source": {
            "type": "file_content",
            "content": [
                {"item": {"query": "What is the capital of France?"}},
                {"item": {"query": "How do I reverse a string in Python?"}},
            ],
        },
        "input_messages": {
            "type": "template",
            "template": [
                {"type": "message", "role": "user", "content": {"type": "input_text", "text": "{{item.query}}"}}
            ],
        },
        "target": {
            "type": "azure_ai_agent",
            "name": agent.name,
            "version": agent.version,  # Version is optional. Defaults to latest version if not specified
        },
    }

    agent_eval_run: Union[RunCreateResponse, RunRetrieveResponse] = openai_client.evals.runs.create(
        eval_id=eval_object.id, name=f"Evaluation Run for Agent {agent.name}", data_source=data_source  # type: ignore
    )
    print(f"Evaluation run created (id: {agent_eval_run.id})")

Deployments operations

The code below shows some Deployments operations, which allow you to enumerate the AI models deployed to your Microsoft Foundry Projects. These models can be seen in "Build" menu, under "Models" (First column of the "Deployments" table) in your Microsoft Foundry project portal. Full samples can be found under the "deployment" folder in the package samples.

print("List all deployments:")
for deployment in project_client.deployments.list():
    print(deployment)

print(f"List all deployments by the model publisher `{model_publisher}`:")
for deployment in project_client.deployments.list(model_publisher=model_publisher):
    print(deployment)

print(f"List all deployments of model `{model_name}`:")
for deployment in project_client.deployments.list(model_name=model_name):
    print(deployment)

print(f"Get a single deployment named `{model_deployment_name}`:")
deployment = project_client.deployments.get(model_deployment_name)
print(deployment)

# At the moment, the only deployment type supported is ModelDeployment
if isinstance(deployment, ModelDeployment):
    print(f"Type: {deployment.type}")
    print(f"Name: {deployment.name}")
    print(f"Model Name: {deployment.model_name}")
    print(f"Model Version: {deployment.model_version}")
    print(f"Model Publisher: {deployment.model_publisher}")
    print(f"Capabilities: {deployment.capabilities}")
    print(f"SKU: {deployment.sku}")
    print(f"Connection Name: {deployment.connection_name}")

Connections operations

The code below shows some Connection operations, which allow you to enumerate the Azure Resources connected to your Microsoft Foundry Projects. These connections can be seen in the "Management Center", in the "Connected resources" tab in your Microsoft Foundry Project. Full samples can be found under the "connections" folder in the package samples.

print("List all connections:")
for connection in project_client.connections.list():
    print(connection)

print("List all connections of a particular type:")
for connection in project_client.connections.list(
    connection_type=ConnectionType.AZURE_OPEN_AI,
):
    print(connection)

print("Get the default connection of a particular type, without its credentials:")
connection = project_client.connections.get_default(connection_type=ConnectionType.AZURE_OPEN_AI)
print(connection)

print("Get the default connection of a particular type, with its credentials:")
connection = project_client.connections.get_default(
    connection_type=ConnectionType.AZURE_OPEN_AI, include_credentials=True
)
print(connection)

print(f"Get the connection named `{connection_name}`, without its credentials:")
connection = project_client.connections.get(connection_name)
print(connection)

print(f"Get the connection named `{connection_name}`, with its credentials:")
connection = project_client.connections.get(connection_name, include_credentials=True)
print(connection)

Dataset operations

The code below shows some Dataset operations. Full samples can be found under the "datasets" folder in the package samples.

print(
    f"Upload a single file and create a new Dataset `{dataset_name}`, version `{dataset_version_1}`, to reference the file."
)
dataset: DatasetVersion = project_client.datasets.upload_file(
    name=dataset_name,
    version=dataset_version_1,
    file_path=data_file,
    connection_name=connection_name,
)
print(dataset)

print(
    f"Upload files in a folder (including sub-folders) and create a new version `{dataset_version_2}` in the same Dataset, to reference the files."
)
dataset = project_client.datasets.upload_folder(
    name=dataset_name,
    version=dataset_version_2,
    folder=data_folder,
    connection_name=connection_name,
    file_pattern=re.compile(r"\.(txt|csv|md)$", re.IGNORECASE),
)
print(dataset)

print(f"Get an existing Dataset version `{dataset_version_1}`:")
dataset = project_client.datasets.get(name=dataset_name, version=dataset_version_1)
print(dataset)

print(f"Get credentials of an existing Dataset version `{dataset_version_1}`:")
dataset_credential = project_client.datasets.get_credentials(name=dataset_name, version=dataset_version_1)
print(dataset_credential)

print("List latest versions of all Datasets:")
for dataset in project_client.datasets.list():
    print(dataset)

print(f"Listing all versions of the Dataset named `{dataset_name}`:")
for dataset in project_client.datasets.list_versions(name=dataset_name):
    print(dataset)

print("Delete all Dataset versions created above:")
project_client.datasets.delete(name=dataset_name, version=dataset_version_1)
project_client.datasets.delete(name=dataset_name, version=dataset_version_2)

Indexes operations

The code below shows some Indexes operations. Full samples can be found under the "indexes" folder in the package samples.

print(f"Create Index `{index_name}` with version `{index_version}`, referencing an existing AI Search resource:")
index = project_client.indexes.create_or_update(
    name=index_name,
    version=index_version,
    index=AzureAISearchIndex(connection_name=ai_search_connection_name, index_name=ai_search_index_name),
)
print(index)

print(f"Get Index `{index_name}` version `{index_version}`:")
index = project_client.indexes.get(name=index_name, version=index_version)
print(index)

print("List latest versions of all Indexes:")
for index in project_client.indexes.list():
    print(index)

print(f"Listing all versions of the Index named `{index_name}`:")
for index in project_client.indexes.list_versions(name=index_name):
    print(index)

print(f"Delete Index `{index_name}` version `{index_version}`:")
project_client.indexes.delete(name=index_name, version=index_version)

Files operations

The code below shows some Files operations using the OpenAI client, which allow you to upload, retrieve, list, and delete files. These operations are useful for working with files that can be used for fine-tuning and other AI model operations. Full samples can be found under the "files" folder in the package samples.

print("Uploading file")
with open(file_path, "rb") as f:
    uploaded_file = openai_client.files.create(file=f, purpose="fine-tune")
print(uploaded_file)

print("Waits for the given file to be processed, default timeout is 30 mins")
processed_file = openai_client.files.wait_for_processing(uploaded_file.id)
print(processed_file)

print(f"Retrieving file metadata with ID: {processed_file.id}")
retrieved_file = openai_client.files.retrieve(processed_file.id)
print(retrieved_file)

print(f"Retrieving file content with ID: {processed_file.id}")
file_content = openai_client.files.content(processed_file.id)
print(file_content.content)

print("Listing all files:")
for file in openai_client.files.list():
    print(file)

print(f"Deleting file with ID: {processed_file.id}")
deleted_file = openai_client.files.delete(processed_file.id)
print(f"Successfully deleted file: {deleted_file.id}")

Fine-tuning operations

The code below shows how to create fine-tuning jobs using the OpenAI client. These operations support various fine-tuning techniques like Supervised Fine-Tuning (SFT), Reinforcement Fine-Tuning (RFT), and Direct Performance Optimization (DPO). Full samples can be found under the "finetuning" folder in the package samples.

See also the Fine-Tuning in AI Foundry repository.

print("Uploading training file...")
with open(training_file_path, "rb") as f:
    train_file = openai_client.files.create(file=f, purpose="fine-tune")
print(f"Uploaded training file with ID: {train_file.id}")

print("Uploading validation file...")
with open(validation_file_path, "rb") as f:
    validation_file = openai_client.files.create(file=f, purpose="fine-tune")
print(f"Uploaded validation file with ID: {validation_file.id}")

print("Waits for the training and validation files to be processed...")
openai_client.files.wait_for_processing(train_file.id)
openai_client.files.wait_for_processing(validation_file.id)

print("Creating supervised fine-tuning job")
fine_tuning_job = openai_client.fine_tuning.jobs.create(
    training_file=train_file.id,
    validation_file=validation_file.id,
    model=model_name,
    method={
        "type": "supervised",
        "supervised": {"hyperparameters": {"n_epochs": 3, "batch_size": 1, "learning_rate_multiplier": 1.0}},
    },
    extra_body={
        "trainingType": "GlobalStandard"
    },  # Recommended approach to set trainingType. Omitting this field may lead to unsupported behavior.
    # Preferred trainingtype is GlobalStandard.  Note:  Global training offers cost savings , but copies data and weights outside the current resource region.
    # Learn more - https://azure.microsoft.com/pricing/details/cognitive-services/openai-service/ and https://azure.microsoft.com/explore/global-infrastructure/data-residency/
)
print(fine_tuning_job)

Tracing

Experimental Feature Gate

Important: GenAI tracing instrumentation is an experimental preview feature. Spans, attributes, and events may be modified in future versions. To use it, you must explicitly opt in by setting the environment variable:

AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING=true

This environment variable must be set before calling AIProjectInstrumentor().instrument(). If the environment variable is not set or is set to any value other than true (case-insensitive), tracing instrumentation will not be enabled and a warning will be logged.

Only enable this feature after reviewing your requirements and understanding that the tracing behavior may change in future versions.

Getting Started with Tracing

You can add an Application Insights Azure resource to your Microsoft Foundry project. See the Tracing tab in your Microsoft Foundry project. If one was enabled, you can get the Application Insights connection string, configure your AI Projects client, and observe traces in Azure Monitor. Typically, you might want to start tracing before you create a client or Agent.

Installation

Make sure to install OpenTelemetry and the Azure SDK tracing plugin via

pip install "azure-ai-projects>=2.0.0b4" opentelemetry-sdk azure-core-tracing-opentelemetry azure-monitor-opentelemetry

You will also need an exporter to send telemetry to your observability backend. You can print traces to the console or use a local viewer such as Aspire Dashboard.

To connect to Aspire Dashboard or another OpenTelemetry compatible backend, install OTLP exporter:

pip install opentelemetry-exporter-otlp

How to enable tracing

Remember: Before enabling tracing, ensure you have set the AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING=true environment variable as described in the Experimental Feature Gate section.

Here is a code sample that shows how to enable Azure Monitor tracing:

# Enable Azure Monitor tracing
application_insights_connection_string = project_client.telemetry.get_application_insights_connection_string()
configure_azure_monitor(connection_string=application_insights_connection_string)

You may also want to create a span for your scenario:

tracer = trace.get_tracer(__name__)
scenario = os.path.basename(__file__)

with tracer.start_as_current_span(scenario):

See the full sample in file \agents\telemetry\sample_agent_basic_with_azure_monitor_tracing.py in the Samples folder.

Note: In order to view the traces in the Microsoft Foundry portal, the agent ID should be passed in as part of the response generation request.

In addition, you might find it helpful to see the tracing logs in the console. Remember to set AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING=true before running the following code:

# Setup tracing to console
# Requires opentelemetry-sdk
span_exporter = ConsoleSpanExporter()
tracer_provider = TracerProvider()
tracer_provider.add_span_processor(SimpleSpanProcessor(span_exporter))
trace.set_tracer_provider(tracer_provider)
tracer = trace.get_tracer(__name__)

# Enable instrumentation with content tracing
AIProjectInstrumentor().instrument()

See the full sample in file \agents\telemetry\sample_agent_basic_with_console_tracing.py in the Samples folder.

Enabling trace context propagation

Trace context propagation allows client-side spans generated by the Projects SDK to be correlated with server-side spans from Azure OpenAI and other Azure services. When enabled, the SDK automatically injects W3C Trace Context headers (traceparent and tracestate) into HTTP requests made by OpenAI clients obtained via get_openai_client().

This feature ensures that all operations within a distributed trace share the same trace ID, providing end-to-end visibility across your application and Azure services in your observability backend (such as Azure Monitor).

To enable trace context propagation, set the AZURE_TRACING_GEN_AI_ENABLE_TRACE_CONTEXT_PROPAGATION environment variable to true:

If no value is provided for the enable_trace_context_propagation parameter with the AIProjectInstrumentor.instrument()call and the environment variable is not set, trace context propagation defaults tofalse` (opt-in).

Important Security and Privacy Considerations:

• Trace IDs: When trace context propagation is enabled, trace IDs are sent to Azure OpenAI and other external services.
• Request Correlation: Trace IDs allow Azure services to correlate requests from the same session or user across multiple API calls, which may have privacy implications depending on your use case.
• Opt-in by Design: This feature is disabled by default to give you explicit control over when trace context is propagated to external services.

Only enable trace context propagation after carefully reviewing your observability, privacy and security requirements.

Controlling baggage propagation

When trace context propagation is enabled, you can separately control whether the baggage header is included. By default, only traceparent and tracestate headers are propagated. To also include the baggage header, set the AZURE_TRACING_GEN_AI_TRACE_CONTEXT_PROPAGATION_INCLUDE_BAGGAGE environment variable to true:

If no value is provided for the enable_baggage_propagation parameter with the AIProjectInstrumentor.instrument() call and the environment variable is not set, the value defaults to false and baggage is not included.

Why is baggage propagation separate?

The baggage header can contain arbitrary key-value pairs added anywhere in your application's trace context. Unlike trace IDs (which are randomly generated identifiers), baggage may contain:

• User identifiers or session information
• Authentication tokens or credentials
• Business-specific data or metadata
• Personally identifiable information (PII)

Baggage is automatically propagated through your entire application's call chain, meaning data added in one part of your application will be included in requests to Azure OpenAI unless explicitly controlled.

Important Security Considerations:

• Review Baggage Contents: Before enabling baggage propagation, audit what data your application (and any third-party libraries) adds to OpenTelemetry baggage.
• Sensitive Data Risk: Baggage is sent to Azure OpenAI and may be logged or processed by Microsoft services. Never add sensitive information to baggage when baggage propagation is enabled.
• Opt-in by Design: Baggage propagation is disabled by default (even when trace context propagation is enabled) to prevent accidental exposure of sensitive data.
• Minimal Propagation: traceparent and tracestate headers are generally sufficient for distributed tracing. Only enable baggage propagation if your specific observability requirements demand it.

Enabling content recording

Content recording controls whether message contents and tool call related details, such as parameters and return values, are captured with the traces. This data may include sensitive user information.

To enable content recording, set the OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT environment variable to true. If the environment variable is not set and no value is provided with the AIProjectInstrumentor().instrument() call for the content recording parameter, content recording defaults to false.

Important: The environment variable only controls content recording for built-in traces. When you use custom tracing decorators on your own functions, all parameters and return values are always traced.

Disabling automatic instrumentation

The AI Projects client library automatically instruments OpenAI responses and conversations operations through AiProjectInstrumentation. You can disable this instrumentation by setting the environment variable AZURE_TRACING_GEN_AI_INSTRUMENT_RESPONSES_API to false. If the environment variable is not set, the responses and conversations APIs will be instrumented by default.

Tracing Binary Data

Binary data are images and files sent to the service as input messages. When you enable content recording (OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT set to true), by default you only trace file IDs and filenames. To enable full binary data tracing, set AZURE_TRACING_GEN_AI_INCLUDE_BINARY_DATA to true. In this case:

• Images: Image URLs (including data URIs with base64-encoded content) are included
• Files: File data is included if sent via the API

Important: Binary data can contain sensitive information and may significantly increase trace size. Some trace backends and tracing implementations may have limitations on the maximum size of trace data that can be sent to and/or supported by the backend. Ensure your observability backend and tracing implementation support the expected trace payload sizes when enabling binary data tracing.

How to trace your own functions

The decorator trace_function is provided for tracing your own function calls using OpenTelemetry. By default the function name is used as the name for the span. Alternatively you can provide the name for the span as a parameter to the decorator.

Note: The OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT environment variable does not affect custom function tracing. When you use the trace_function decorator, all parameters and return values are always traced by default.

This decorator handles various data types for function parameters and return values, and records them as attributes in the trace span. The supported data types include:

• Basic data types: str, int, float, bool
• Collections: list, dict, tuple, set
  • Special handling for collections:
    • If a collection (list, dict, tuple, set) contains nested collections, the entire collection is converted to a string before being recorded as an attribute.
    • Sets and dictionaries are always converted to strings to ensure compatibility with span attributes.

Object types are omitted, and the corresponding parameter is not traced.

The parameters are recorded in attributes code.function.parameter.<parameter_name> and the return value is recorder in attribute code.function.return.value

Adding custom attributes to spans

You can add custom attributes to spans by creating a custom span processor. Here's how to define one:

class CustomAttributeSpanProcessor(SpanProcessor):
    def __init__(self) -> None:
        pass

    def on_start(self, span: Span, parent_context=None):
        # Add this attribute to all spans
        span.set_attribute("trace_sample.sessionid", "123")

        # Add another attribute only to create_thread spans
        if span.name == "create_thread":
            span.set_attribute("trace_sample.create_thread.context", "abc")

    def on_end(self, span: ReadableSpan):
        # Clean-up logic can be added here if necessary
        pass

Then add the custom span processor to the global tracer provider:

provider = cast(TracerProvider, trace.get_tracer_provider())
provider.add_span_processor(CustomAttributeSpanProcessor())

See the full sample in file \agents\telemetry\sample_agent_basic_with_console_tracing_custom_attributes.py in the Samples folder.

Additional resources

For more information see Agent tracing overview (preview).

Troubleshooting

Exceptions

Client methods that make service calls raise an HttpResponseError exception for a non-success HTTP status code response from the service. The exception's status_code will hold the HTTP response status code (with reason showing the friendly name). The exception's error.message contains a detailed message that may be helpful in diagnosing the issue:

from azure.core.exceptions import HttpResponseError

...

try:
    result = project_client.connections.list()
except HttpResponseError as e:
    print(f"Status code: {e.status_code} ({e.reason})")
    print(e.message)

For example, when you provide wrong credentials:

Status code: 401 (Unauthorized)
Operation returned an invalid status 'Unauthorized'

Logging

The client uses the standard Python logging library. The logs include HTTP request and response headers and body, which are often useful when troubleshooting or reporting an issue to Microsoft.

Default console logging

To turn on client console logging define the environment variable AZURE_AI_PROJECTS_CONSOLE_LOGGING=true before running your Python script. Authentication bearer tokens are automatically redacted from the log. Your log may contain other sensitive information, so be sure to remove it before sharing the log with others.

Customizing your log

Instead of using the above-mentioned environment variable, you can configure logging yourself and control the log level, format and destination. To log to stdout, add the following at the top of your Python script:

import sys
import logging

# Acquire the logger for this client library. Use 'azure' to affect both
# 'azure.core` and `azure.ai.inference' libraries.
logger = logging.getLogger("azure")

# Set the desired logging level. logging.INFO or logging.DEBUG are good options.
logger.setLevel(logging.DEBUG)

# Direct logging output to stdout:
handler = logging.StreamHandler(stream=sys.stdout)
# Or direct logging output to a file:
# handler = logging.FileHandler(filename="sample.log")
logger.addHandler(handler)

# Optional: change the default logging format. Here we add a timestamp.
#formatter = logging.Formatter("%(asctime)s:%(levelname)s:%(name)s:%(message)s")
#handler.setFormatter(formatter)

By default logs redact the values of URL query strings, the values of some HTTP request and response headers (including Authorization which holds the key or token), and the request and response payloads. To create logs without redaction, add logging_enable=True to the client constructor:

project_client = AIProjectClient(
    credential=DefaultAzureCredential(),
    endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
    logging_enable=True
)

Note that the log level must be set to logging.DEBUG (see above code). Logs will be redacted with any other log level.

Be sure to protect non redacted logs to avoid compromising security.

For more information, see Configure logging in the Azure libraries for Python

Reporting issues

To report an issue with the client library, or request additional features, please open a GitHub issue here. Mention the package name "azure-ai-projects" in the title or content.

Next steps

Have a look at the Samples folder, containing fully runnable Python code for synchronous and asynchronous clients.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact [e-mail] with any additional questions or comments.

Release History

2.0.1 (2026-03-12)

Bugs Fixed

• Fix custom Memory Stores LRO poller operation to add the missing required "Foundry-Features": "MemoryStores=V1Preview" HTTP request header.

2.0.0 (2026-03-06)

First stable release of the client library that uses the Generally Available (GA) version "v1" of the Foundry REST APIs.

Features Added

• To enable preview (beta) operations, a new optional boolean input argument named allow_preview was added to the constructor of AIProjectClient. Caller must set it to True to opt-in to preview features. This includes creating an Hosted Agent or Workflow Agent. Methods on the .beta sub-client (for example .beta.memory_stores.create()) do not require setting allow_preview=True since it's implied by the sub-client name. When preview features are enabled, the client libraries sends the HTTP request header Foundry-Features with the appropriate value in all relevant calls to the service.

Breaking Changes

• Input argument foundry_features was removed from all methods that supported it. Use the new allow_preview instead on client constructor (see above).
• Class TextResponseFormatConfiguration renamed to TextResponseFormat.
• Class TextResponseFormatConfigurationResponseFormatText renamed to TextResponseFormatTest.
• Class TextResponseFormatConfigurationResponseFormatJsonObject renamed to TextResponseFormatJsonObject.
• Class CodeInterpreterContainerAuto was renamed to AutoCodeInterpreterToolParam, and has a new optional property network_policy of type ContainerNetworkPolicyParam.
• class ImageGenActionEnum was renamed to ImageGenAction.
• Rename ToolChoiceParamType.WEB_SEARCH_PREVIEW2025_03_11 to ToolChoiceParamType.WEB_SEARCH_PREVIEW_2025_03_11.
• Rename RankerVersionType.DEFAULT2024_11_15 to RankerVersionType.DEFAULT_2024_11_15.
• Rename method .beta.evaluators.list_latest_versions() to .beta.evaluators.list().
• Rename property id on class Insight to insight_id.
• Rename property id on class Schedule to schedule_id.
• Rename input argument id to insight_id in .beta.insights.get() method.
• Rename input argument id to schedule_id in .beta.schedules methods.
• Updated datetime-typed fields (start_time, end_time, trigger_at, trigger_time, created_at, modified_at) across CronTrigger, RecurrenceTrigger, OneTimeTrigger, ScheduleRun, and EvaluatorVersion classes from str to datetime.datetime with format="rfc3339".

Other Changes

• The input items argument in the methods .beta.memory_stores.begin_update_memories() and .beta.memory_stores.search_memories was change from type Optional[List[dict[str, Any]]] to Optional[Union[str, ResponseInputParam]]. The class ResponseInputParam can be imported using from openai.types.responses import EasyInputMessageParam. This is not a breaking change, since the caller can still pass in List[dict[str, Any].

2.0.0b4 (2026-02-24)

This is the first release that uses the Generally Available (GA) version "v1" of the Foundry REST APIs.

Features Added

• Tracing: included agent ID in response generation traces when available.
• Tracing: Added support for opt-in trace context propagation.

Breaking changes

• A Responses call on OpenAPI client (openai_client.responses.create()) that uses an Agent reference, now needs to specify extra_body={"agent_reference": {"name": agent_name, "type": "agent_reference"}} instead of extra_body={"agent": {"name": agent_name, "type": "agent_reference"}}.
• Agent methods .agents.create(), .agents.create_from_manifest(), .agents.update() and .agents.update_from_manifest() were removed. Use the remaining methods .agents.create_version() and .agents.create_version_from_manifest() instead.
• To align with OpenAI naming conventions, use "Tool" suffix for class names describing Azure tools that are generally available (stable release):
  • Rename class AzureAISearchAgentTool to AzureAISearchTool.
  • Rename class AzureFunctionAgentTool to AzureFunctionTool.
  • Rename class BingGroundingAgentTool to BingGroundingTool.
  • Rename class OpenApiAgentTool to OpenApiTool.
• To align with OpenAI naming conventions, use "PreviewTool" suffix for class names describing Azure tools in preview:
  • Rename class A2ATool to A2APreviewTool.
  • Rename class BingCustomSearchAgentTool to BingCustomSearchPreviewTool.
  • Rename class BrowserAutomationAgentTool to BrowserAutomationPreviewTool.
  • Rename class MemorySearchTool to MemorySearchPreviewTool.
  • Rename class MicrosoftFabricAgentTool to MicrosoftFabricPreviewTool.
  • Rename class SharepointAgentTool to SharepointPreviewTool.
• Other class renames:
  • Rename class PromptAgentDefinitionText to PromptAgentDefinitionTextOptions
  • Rename class EvaluationComparisonRequest to InsightRequest
• To use Workflow Agents, which are still in preview, you now need to set an additional input argument foundry_features=FoundryFeaturesOptInKeys.WORKFLOW_AGENTS_V1_PREVIEW when calling .agents.create_version().
• To use Hosted Agents, which are still in preview, you now need to set an additional input argument foundry_features=FoundryFeaturesOptInKeys.HOSTED_AGENTS_V1_PREVIEW when calling .agents.create_version().
• To use .evaluation_rules.create_or_update() with HumanEvaluationPreviewRuleAction, you now need to set an additional input argument foundry_features=FoundryFeaturesOptInKeys.EVALUATIONS_V1_PREVIEW.
• Operation sets that are still in preview now have the ".beta" subclient in their call path. So for example project_client.memory_stores.create() has changed to project_client.beta.memory_stores.create(). Similarly for the operation sets: evaluators, insights, evaluation_taxonomies, schedules and red_teams.
• The method begin_update_memories() in Memory Stores operation now accept optional items of type List[dict[str, Any]] instead of List[ItemParam]. Similarly for items in method search_memories(). As a result around 100 classes that are derived from ItemParam were removed as they are no longer used by the client library.
• Tracing instrumentation, is an experimental preview feature, now requires explicitly opt in by setting the environment variable: AZURE_EXPERIMENTAL_ENABLE_GENAI_TRACING=true
• Tracing: workflow actions in conversation item listings are now emitted as "gen_ai.conversation.item" events (with role="workflow") instead of "gen_ai.workflow.action" events in the list_conversation_items span.
• Tracing: response generation span names changed from "responses {model_name}" to "chat {model_name}" for model calls and from "responses {agent_name}" to "invoke_agent {agent_name}" for agent calls.
• Tracing: response generation operation names changed from "responses" to "chat" for model calls and from "responses" to "invoke_agent" for agent calls.
• Tracing: response generation uses gen_ai.input.messages and gen_ai.output.messages attributes directly under the span instead of events.
• Tracing: agent creation uses gen_ai.system_instructions attribute directly under the span instead of an event. Note that the attribute name is gen_ai.system_instructions not gen_ai.system.instructions.
• Tracing: "gen_ai.provider.name" attribute value changed to "microsoft.foundry".
• Tracing: the format of the function tool call related traces in input and output messages changed to {"type": "tool_call", "id": "...", "name": "...", "arguments": {...}} and {"type": "tool_call_response", "id": "...", "result": "..."}

Sample updates

• Add and update samples for AzureFunctionTool, WebSearchTool, and WebSearchPreviewTool
• All samples for agent tools call responses.create API with agent_reference instead of agent

2.0.0b3 (2026-01-06)

Features Added

• The package now takes dependency on openai and azure-identity packages. No need to install them separately.
• Tracing: support for tracing the schema when an Agent is created with structured output definition.

Breaking changes

• Rename class AgentObject to AgentDetails
• Rename class AgentVersionObject to AgentVersionDetails
• Rename class MemoryStoreObject to MemoryStoreDetails
• Tracing: removed outer "content" from event content format wrapper and unified type-specific keys (e.g., "text", "image_url") to generic "content" key.
• Tracing: replaced "gen_ai.request.assistant_name" attribute with gen_ai.agent.name.
• Tracing: removed "gen_ai.system" - the "gen_ai.provider.name" provides same information.
• Tracing: changed "gen_ai.user.message" and "gen_ai.tool.message" to "gen_ai.input.messages". Changed "gen_ai.assistant.message" to "gen_ai.output.messages".
• Tracing: changed "gen_ai.system.instruction" to "gen_ai.system.instructions".
• Tracing: added the "parts" array to "gen_ai.input.messages" and "gen_ai.output.messages".
• Tracing: removed "role" as a separate attribute and added "role" to "gen_ai.input.messages" and "gen_ai.output.messages" content.
• Tracing: added "finish_reason" as part of "gen_ai.output.messages" content.
• Tracing: changed the tool calls to use the api definitions as the types in traces. For example "function_call" instead of "function" and "function_call_output" instead of "function"

Bugs Fixed

• Tracing: fixed a bug with computer use tool call output including screenshot binary data even when binary data tracing is off.

Sample updates

• Added OpenAPI tool sample. See sample_agent_openapi.py.
• Added OpenAPI with Project Connection sample. See sample_agent_openapi_with_project_connection.py.
• Added SharePoint grounding tool sample. See sample_agent_sharepoint.py.
• Improved MCP client sample showing direct MCP tool invocation. See samples/mcp_client/sample_mcp_tool_async.py.
• Samples that download generated files (code interpreter and image generation) now save files to the system temp directory instead of the current working directory. See sample_agent_code_interpreter.py, sample_agent_code_interpreter_async.py, sample_agent_image_generation.py, and sample_agent_image_generation_async.py.
• The Agent to Agent sample was updated to allow "Custom keys" connection type.
• Update Fine-Tuning supervised job samples to show waiting for model result instead of polling
• Add evaluations sample samples/evaluations/sample_evaluations_score_model_grader_with_image.py.
• Add basic steam event samples samples/agents/sample_agent_stream_events.py and samples/responses/sample_responses_stream_events.py

2.0.0b2 (2025-11-14)

Features Added

• Tracing: support for workflow agent tracing.
• Agent Memory operations, including code for custom LRO poller. See methods on the ".memory_store" property of AIProjectClient.

Breaking changes

• get_openai_client() method on the asynchronous AIProjectClient is no longer an "async" method.
• Tracing: tool call output event content format updated to be in line with other events.

Bugs Fixed

• Tracing: operation name attribute added to create agent span, token usage added to streaming response generation span.

Sample updates

• Added samples to show usage of the Memory Search Tool (see sample_agent_memory_search.py) and its async equivalent.
• Added samples to show Memory management. See samples in the folder samples\memories.
• Added finetuning samples for operations create, retrieve, list, list_events, list_checkpoints, cancel, pause and resume. Also, these samples includes various finetuning techniques like Supervised (SFT), Reinforcement (RFT) and Direct performance optimization (DPO).
• In all most samples, credential, project client, and openai client are combined into one context manager.
• Remove await while calling get_openai_client() for samples using asynchronous clients.

2.0.0b1 (2025-11-11)

Features added

• The client library now uses version 2025-11-15-preview of the Microsoft Foundry data plane REST APIs.
• New Agent operations (now built on top of OpenAI's Responses protocol) were added to the AIProjectClient. This package no longer depends on azure-ai-agents package. See samples\agents folder.
• New Evaluation operations. See methods on properties .evaluation_rules, .evaluation_taxonomies, .evaluators, .insights, and .schedules.
• New Memory Store operations. See methods on the property .memory_store.

Breaking changes

• The implementation of .get_openai_client() method was updated to return an authenticated OpenAI client from the openai package, configure to run Responses operations on your Foundry Project endpoint.

Sample updates

• Added new Agent samples. See samples\agents folder.
• Added new Evaluation samples. See samples\evaluations folder.
• Added files samples for operations create, delete, list, retrieve and content. See samples\files folder.

1.1.0b4 (2025-09-12)

Bugs Fixed

• Fix getting secret keys for connections of type "Custom Keys" (GitHub issue 52355)

1.1.0b3 (2025-08-26)

Features added

• File setup.py was updated to indicate the dependency azure-ai-agents>=1.2.0b3 instead of azure-ai-agents>=1.0.0. This means that in a clean environment, installing via pip install --pre azure-ai-projects will install latest beta version of azure-ai-agents (which has features in preview) instead of latest stable version (which does not include preview features).

1.1.0b2 (2025-08-05)

Bugs Fixed

Fix regression in Red-Team operations, in the definition of the class AzureOpenAIModelConfiguration.

1.1.0b1 (2025-08-01)

First beta version following the 1.0.0 stable release. It brings back the Evaluation and Red-Team operations which are still in preview.

Features added

• Evaluation and Red-Team operations (in preview) were restored.

1.0.0 (2025-07-31)

First stable version of the client library. The client library now uses version v1 of the AI Foundry data plane REST APIs.

Breaking changes

• Features that are still in preview were removed from this stable release. This includes:
  • Evaluation operations (property .evaluations)
  • Red-Team operations (property .red_teams)
  • Class PromptTemplate.
  • Package function enable_telemetry()
• Classes were renamed:
  • Class Sku was renamed ModelDeploymentSku
  • Class SasCredential was renamed BlobReferenceSasCredential
  • Class AssetCredentialResponse was renamed DatasetCredential
• Method .inference.get_azure_openai_client() was renamed .get_openai_client(). The .inference property was removed. The method is documented as returning an object of type OpenAI, but it still returns an object of the derived type AzureOpenAI. The function implementation has not changed.
• Method .telemetry.get_connection_string() was renamed .telemetry.get_application_insights_connection_string()

Sample updates

• Added a new Dataset sample named sample_datasets_download.py to show how you can download all files referenced by a certain Dataset (following a question in this GitHub issue)
• Two samples added showing how to do a responses operation using an authenticated Azure OpenAI client created using get_openai_client().
• Existing inference samples that used the package function enable_telemetry() were updated to remove this call, and instead add the necessary tracing configuration calls to the sample.

1.0.0b12 (2025-06-23)

Breaking changes

• These 3 methods on AIProjectClient were removed: .inference.get_chat_completions_client(), .inference.get_embeddings_client() and .inference.get_image_embeddings_client(). For guidance on obtaining an authenticated azure-ai-inference client for your AI Foundry Project, refer to the updated samples in the samples\inference directory. For example, sample_chat_completions_with_azure_ai_inference_client.py. Alternatively, use the .inference.get_azure_openai_client() method to perform chat completions with an Azure OpenAI client.
• Method argument name changes:
  • In method .indexes.create_or_update() argument body was renamed index.
  • In method .datasets.create_or_update() argument body was renamed dataset_version.
  • In method .datasets.pending_upload() argument body was renamed pending_upload_request.

Bugs Fixed

• Fix to package function enable_telemetry() to correctly instrument azure-ai-agents.
• Updated RedTeam target type visibility to allow for type being sent in the JSON for redteam run creation.

Other

• Set dependency on azure-ai-agents version 1.0.0 or above, now that we have a stable release of the Agents package.

1.0.0b11 (2025-05-15)

There have been significant updates with the release of version 1.0.0b11, including breaking changes. Please see new samples and package README.md file.

Features added

• .deployments methods to enumerate AI models deployed to your AI Foundry Project.
• .datasets methods to upload documents and reference them. To be used with Evaluations.
• .indexes methods to handle your Search Indexes.

Breaking changes

• Azure AI Foundry Project endpoint is now required to construct the AIProjectClient. It has the form https://<your-ai-services-account-name>.services.ai.azure.com/api/projects/<your-project-name>. Find it in your AI Foundry Project Overview page. The factory method from_connection_string was removed. Support for project connection string and hub-based projects has been discontinued. We recommend creating a new Azure AI Foundry resource utilizing project endpoint. If this is not possible, please pin the version of or pin the version of azure-ai-projects to 1.0.0b10 or earlier.
• Agents are now implemented in a separate package azure-ai-agents. Continue using the ".agents" operations on the AIProjectsClient to create, run and delete agents, as before. However there have been some breaking changes in these operations. See Agents package document and samples for more details.
• Several changes to the .connections methods, including the response object (now simply called Connection)
• The method .inference.get_azure_openai_client() now supports returning an authenticated AzureOpenAI client to be used with AI models deployed to the Project's AI Services. This is in addition to the existing option to get an AzureOpenAI client for one of the connected Azure OpenAI services.
• Import PromptTemplate from azure.ai.projects instead of azure.ai.projects.prompts.
• The class ConnectionProperties was renamed to Connection, and its properties have changed.
• The method .to_evaluator_model_config on ConnectionProperties is no longer required and does not have an equivalent method on Connection. When constructing the EvaluatorConfiguration class, the init_params element now requires deployment_name instead of model_config.
• The method upload_file on AIProjectClient had been removed, use datasets.upload_file instead.
• Evaluator Ids are available using the Enum EvaluatorIds and no longer require azure-ai-evaluation package to be installed.
• Property scope on AIProjectClient is removed, use AI Foundry Project endpoint instead.
• Property id on Evaluation is replaced with name.
• Please see the agents migration guide on how to use the new azure-ai-projects with azure-ai-agents package.

Sample updates

• All samples have been updated. New ones added for Deployments, Datasets and Indexes.

1.0.0b10 (2025-04-23)

Features added

• Added ConnectedAgentTool class for better connected Agent support.
• Added Agent tool call tracing for all tool call types when streaming with AgentEventHandler based event handler.
• Added tracing for listing Agent run steps.
• Add a max_retry argument to the Agent's enable_auto_function_calls function to cancel the run if the maximum number of retries for auto function calls is reached.

Sample updates

• Added connected Agent tool sample.

Bugs Fixed

• Fix for filtering of Agent messages by run ID (see GitHub issue 49513).

1.0.0b9 (2025-04-16)

Features added

• Utilities to load prompt template strings and Prompty file content
• Added BingCustomSearchTool class with sample
• Added list_threads API to agents namespace
• Added image input support for agents create_message

Sample updates

• Added project_client.agents.enable_auto_function_calls(toolset=toolset) to all samples that has toolcalls executed by azure-ai-project SDK
• New BingCustomSearchTool sample
• New samples added for image input from url, file and base64

Breaking Changes

Redesigned automatic function calls because agents retrieved by update_agent and get_agent do not support them. With the new design, the toolset parameter in create_agent no longer executes toolcalls automatically during create_and_process_run or create_stream. To retain this behavior, call enable_auto_function_calls without additional changes.

1.0.0b8 (2025-03-28)

Features added

• New parameters added for Azure AI Search tool, with corresponding sample update.
• Fabric tool REST name updated, along with convenience code.

Sample updates

• Sample update demonstrating new parameters added for Azure AI Search tool.
• Sample added using OpenAPI tool against authenticated TripAdvisor API spec.

Bugs Fixed

• Fix for a bug in Agent tracing causing event handler return values to not be returned when tracing is enabled.
• Fix for a bug in Agent tracing causing tool calls not to be recorded in traces.
• Fix for a bug in Agent tracing causing function tool calls to not work properly when tracing is enabled.
• Fix for a bug in Agent streaming, where agent_id was not included in the response. This caused the SDK not to make function calls when the thread run status is requires_action.

1.0.0b7 (2025-03-06)

Features added

• Add support for parsing URL citations in Agent text messages. See new classes MessageTextUrlCitationAnnotation and MessageDeltaTextUrlCitationAnnotation.
• Add enum value ConnectionType.API_KEY to support enumeration of generic connections that uses API Key authentication.

Sample updates

• Update sample sample_agents_bing_grounding.py with printout of URL citation.
• Add new samples sample_agents_stream_eventhandler_with_bing_grounding.py and sample_agents_stream_iteration_with_bing_grounding.py with printout of URL citation.

Bugs Fixed

• Fix a bug in deserialization of RunStepDeltaFileSearchToolCall returned during Agent streaming (see GitHub issue 48333).
• Fix for Exception raised while parsing Agent streaming response, in some rare cases, for multibyte UTF-8 languages like Chinese.

Breaking Changes

• Rename input argument assistant_id to agent_id in all Agent methods to align with the "Agent" terminology. Similarly, rename all assistant_id properties on classes.

1.0.0b6 (2025-02-14)

Features added

• Added trace_function decorator for conveniently tracing function calls in Agents using OpenTelemetry. Please see the README.md for updated documentation.

Sample updates

• Added AzureLogicAppTool utility and Logic App sample under samples/agents, folder to make Azure Logic App integration with Agents easier.
• Added better observability for Azure AI Search sample for Agents via improved run steps information from the service.
• Added sample to demonstrate how to add custom attributes to telemetry span.

Bugs Fixed

• Lowered the logging level of "Toolset is not available in the client" from warning to debug to prevent unnecessary log entries in agent application runs.

1.0.0b5 (2025-01-17)

Features added

• Add method .inference.get_image_embeddings_client on AIProjectClient to get an authenticated ImageEmbeddingsClient (from the package azure-ai-inference). You need to have azure-ai-inference package version 1.0.0b7 or above installed for this method to work.

Bugs Fixed

• Fix for events dropped in streamed Agent response (see GitHub issue 39028).
• In Agents, incomplete status thread run event is now deserialized into a ThreadRun object, during stream iteration, and invokes the correct function on_thread_run (instead of the wrong function on_unhandled_event).
• Fix an error when calling the to_evaluator_model_config method of class ConnectionProperties. See new input argument include_credentials.

Breaking Changes

• submit_tool_outputs_to_run returns None instead of ThreadRun (see GitHub issue 39028).

1.0.0b4 (2024-12-20)

Bugs Fixed

• Fix for Agent streaming issue (see GitHub issue 38918)
• Fix for Agent async function send_email_async is not called (see GitHub issue 38898)
• Fix for Agent streaming with event handler fails with "AttributeError: 'MyEventHandler' object has no attribute 'buffer'" (see GitHub issue 38897)

Features Added

• Add optional input argument connection_name to methods .inference.get_chat_completions_client, .inference.get_embeddings_client and .inference.get_azure_openai_client.

1.0.0b3 (2024-12-13)

Features Added

• Add support for Structured Outputs for Agents.
• Add option to include file contents, when index search is used for Agents.
• Added objects to inform Agents about Azure Functions.
• Redesigned streaming and event handlers for agents.
• Add parallel_tool_calls parameter to allow parallel tool execution for Agents.
• Added BingGroundingTool for Agents to use against a Bing API Key connection.
• Added AzureAiSearchTool for Agents to use against an Azure AI Search resource.
• Added OpenApiTool for Agents, which creates and executes a REST function defined by an OpenAPI spec.
• Added new helper properties in OpenAIPageableListOfThreadMessage, MessageDeltaChunk, and ThreadMessage.
• Rename "AI Studio" to "AI Foundry" in package documents and samples, following recent rebranding.

Breaking Changes

• The method .agents.get_messages was removed. Please use .agents.list_messages instead.

1.0.0b2 (2024-12-03)

Bugs Fixed

• Fix a bug in the .inference operations when Entra ID authentication is used by the default connection.
• Fixed bugs occurring during streaming in function tool calls by asynchronous agents.
• Fixed bugs that were causing issues with tracing agent asynchronous functionality.
• Fix a bug causing warning about unclosed session, shown when using asynchronous credentials to create agent.
• Fix a bug that would cause agent function tool related function names and parameters to be included in traces even when content recording is not enabled.

1.0.0b1 (2024-11-15)

Features Added

First beta version