Publish and use your agent

(VIDEO TO BE ADDED)

(TEXT IN DEVELOPMENT)

An agent built in Foundry is exposed through a published endpoint, and consumed by an application that users can interact with locally.

By the end of the exercise, you’ll have a clearer picture of how agent development moves from prototyping in tools like Foundry and Visual Studio Code into application integration.

This exercise is available in a hosted lab environment, provided by our partner Skillable.

Launch Hosted Lab

Use these instructions to complete the exercise in your own Azure subscription and development environment.

Before you start

Use the setup guide to prepare your environment. Then complete the previous lab in this series.

When you’re ready, follow the instructions below to create a client app for your first agent.

In the previous exercises, you used Microsoft Foundry and Visual Studio Code to develop a computing history agent.

Now you’re ready to consume it in an application.

Publish your agent

So far you’ve developed and tested your agent within a Foundry project. To take it into production, you need to publish it to a dedicated endpoint from which client applications can consume it.

1. In a web browser, open Microsoft Foundry at https://ai.azure.com and sign in using your Azure credentials.
2. Switch to the New Foundry view if necessary, and open the project in which you created the computing-historian agent.
3. Select the Build menu, and in the Agents page, select the computing-historian agent.

4. In the Publish drop-down list, view the published agent details. In particular, note the Responses API endpoint that clients apps can use to connect to your agent. You’ll need this later!

   Tip: Do not publish your agent to Teams and Microsoft 365 in ths exercise.

Configure a client application in Visual Studio Code

A partially completed client application for your agent has been provided. You’ll complete this app and test it with your agent endpoint.

1. Open Visual Studio Code.

2. Open the command palette (Ctrl+Shift+P) and use the Git:clone command to clone the https://github.com/MicrosoftLearning/mslearn-agent-quickstart repo to a local folder (it doesn’t matter which one). Then open it.

   You may be prompted to confirm you trust the authors.

3. View the Extensions pane; and if it is not already installed, install the Python extension.

4. In the Command Palette, use the command python:create envionment(or python:select interpreter) to create a new Venv environment based on your Python 3.1x installation.

   Tip: If you are prompted to install dependencies, you can install the ones in the requirements.txt file in the /computer-history-client folder; but it’s OK if you don’t - we’ll install them later!

   Wait for the environment to be created.

5. In the Explorer pane, navigate to the folder containing the application code files at /computer-history-client. The application files include:
   • .env (the application configuration file)
   • agent_client.py (the code file for the Python code to interact with your agent)
   • app.py (the main code file for a Python Flask-based web application)
   • README.md (information about the app)
   • requirements.txt (the Python package dependencies that need to be installed)

6. In the Explorer pane, right-click the agent_client.py file, and select Open in integrated terminal.

   Note: Opening the terminal in Visual Studio Code will automatically activate the Python environment. If you’re using a PowerShell terminal by default, you may need to enable running scripts on your system. See Set-ExecutionPolicy for details.

7. Ensure that the terminal is open in the /computer-history-client folder with the prefix (.venv) to indicate that the Python environment you created is active.

8. Install the required Python packages by running the following command:

    pip install -r requirements.txt
   

9. In the Explorer pane, in the /computer-history-client folder, select the .env file to open it. Then update the configuration values to replace your_agent_endpoint_url with the Responses API endpoint for your published agent.
10. Save the updated .env file.

Add code to interact with your agent

Now you’re ready to implement the code that will submit prompts to your agent.

1. In the Explorer pane, in the /computer-history-client folder, select the agent_client.py file (not app.py) to open it.

2. Review the existing code. You will add code to use the OpenAI Response API to interact with your agent.

   Tip: As you add code to the code file, be sure to maintain the correct indentation.

3. Find the comment Import Azure Identity and OpenAI client libraries, and add the following code to import the Azure Identity classes required to use Entra ID authentication, and the OpenAI library.

   # Import Azure Identity and OpenAI client libraries
   from azure.identity import DefaultAzureCredential, get_bearer_token_provider
   from openai import OpenAI
   

4. In the AgentClient class, in the **init** function, note that code has been provided to load the agent endpoint from the environment configuration file. Then find the comment Create OpenAI client authenticated with Azure credentials and add the following code to create an authenticated OpenAI client for your agent:

   # Create OpenAI client authenticated with Azure credentials 
   self.client = OpenAI(
        api_key=get_bearer_token_provider(
            DefaultAzureCredential(), 
            "https://ai.azure.com/.default"
        ),
        base_url=self.agent_endpoint,
        default_query={"api-version": "2025-11-15-preview"}
   )
   

5. In the send_message function, note that code to add the user’s prompt to the conversation history has been provided. Then, in the try block, find the comment Send prompt with full conversation history and get response and add the following code to submit the prompt to the agent and get the response.

   # Send prompt with full conversation history and get response
   response = self.client.responses.create(
        input=self.conversation_history
   )
   assistant_message = response.output_text
   

6. Read through the rest of the code, using the comments to understand the technique of tracking user inputs and responses in a conversation history.
7. Save the updated agent_client.py file.

Run the client application

Now you’re ready to test the app with your agent.

1. In the terminal, use the following command to sign into Azure.

    az login
   

   Note: In most scenarios, just using az login will be sufficient. However, if you have subscriptions in multiple tenants, you may need to specify the tenant by using the –tenant parameter. See Sign into Azure interactively using the Azure CLI for details.

2. When prompted, follow the instructions to sign into Azure. Then complete the sign in process in the command line, viewing (and confirming if necessary) the details of the subscription containing your Foundry resource.

3. After you have signed in, enter the following command to run the application:

   python app.py
   

4. When the Flask application starts, open your browser and navigate to http://localhost:5000 (http://localhost:5000).

   The application web site should looks like this:

   

5. Enter a prompt, such as What was ENIAC? and view the response.
6. Follow up with a second prompt, such as How does it compare with COLOSSUS?
7. When you’re finished testing the app, in the terminal pane, enter CTRL+C to stop the local web server.