Use Azure OpenAI in Foundry Models

Azure OpenAI terms — defined before code

Creating an Azure OpenAI resource

Azure OpenAI is a separate resource type from standard Azure AI Services. It requires a separate application and approval process for new customers.

How to call GPT-4o from Python

The Chat Completions API is the primary way to interact with GPT models. Before the code, understand the three roles in a conversation:

Single-turn call (one question, one answer)

import os
from openai import AzureOpenAI   # Install: pip install openai

# Create the Azure OpenAI client
# azure_endpoint: your Azure OpenAI resource endpoint (openai.azure.com)
# api_key: your Azure OpenAI key
# api_version: ALWAYS specify — ensures consistent behaviour as Azure updates
client = AzureOpenAI(
    azure_endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT"),
    api_key        = os.environ.get("AZURE_OPENAI_KEY"),
    api_version    = "2024-02-01"
)

# chat.completions.create() sends the conversation to the model
# model=: your DEPLOYMENT NAME (not the model name like "gpt-4o")
# messages=: a list of dictionaries — each one is a message with role and content
response = client.chat.completions.create(
    model    = "my-gpt4o",   # Your deployment name from Foundry
    messages = [
        {
            "role"   : "system",   # System message sets behaviour
            "content": "You are a helpful AI assistant that explains things simply."
        },
        {
            "role"   : "user",     # User message is the question
            "content": "What is the difference between AI and machine learning?"
        }
    ]
)

# Extract the model's response text
# response.choices is a list of possible responses (usually 1)
# [0] gets the first response
# .message.content is the text the model generated
answer = response.choices[0].message.content
print(f"Response: {answer}")

# You can also check token usage (important for cost monitoring)
# response.usage shows how many tokens were used
print(f"Tokens used — Prompt: {response.usage.prompt_tokens}, "
      f"Completion: {response.usage.completion_tokens}, "
      f"Total: {response.usage.total_tokens}")

Multi-turn conversation (chatbot)

For a chatbot, you maintain the conversation history by appending each message to the list before sending. New Python concept: list.append() — adds a new item to the end of a list. Explained in comments.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
    azure_endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT"),
    api_key        = os.environ.get("AZURE_OPENAI_KEY"),
    api_version    = "2024-02-01"
)

# Start with just the system message in the conversation history
# This list grows as the conversation continues
conversation_history = [
    {"role": "system", "content": "You are a helpful banking assistant."}
]

# Simulate a 2-turn conversation
user_inputs = [
    "What is the current interest rate on savings accounts?",
    "How does that compare to a fixed-term deposit?"   # Follow-up question
]

# New concept: for loop over a list (from Part 1 Topic 4)
# "for user_input in user_inputs:" runs once for each item in the list
for user_input in user_inputs:

    # Step 1: Add the user's message to the history
    # list.append() adds a new item to the END of the list
    # So conversation_history grows by one message each iteration
    conversation_history.append({
        "role"   : "user",
        "content": user_input
    })

    # Step 2: Send the ENTIRE conversation history to the model
    # The model reads all previous messages and responds in context
    response = client.chat.completions.create(
        model    = "my-gpt4o",
        messages = conversation_history  # Full history — not just the latest message
    )

    # Step 3: Extract the assistant's reply
    assistant_reply = response.choices[0].message.content
    print(f"User: {user_input}")
    print(f"Assistant: {assistant_reply}\n")

    # Step 4: Add the assistant's reply to the history
    # This is crucial — without this the model loses memory of what it said
    conversation_history.append({
        "role"   : "assistant",
        "content": assistant_reply
    })

Using GPT models to write code

GPT-4o and GPT-3.5-turbo are excellent at generating, explaining, and fixing code. The same Chat Completions API is used — you just craft a code-focused prompt.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
    azure_endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT"),
    api_key        = os.environ.get("AZURE_OPENAI_KEY"),
    api_version    = "2024-02-01"
)

# Code generation — the system prompt tells the model to act as a coding assistant
# The user message asks for code in Python
response = client.chat.completions.create(
    model = "my-gpt4o",
    messages = [
        {
            "role"   : "system",
            "content": "You are an expert Python developer. Provide clean, commented code."
        },
        {
            "role"   : "user",
            "content": "Write a Python function that reads a CSV file and returns a list of dictionaries, "
                       "where each dictionary represents a row with column names as keys."
        }
    ]
)

# The model returns Python code as text inside its response
generated_code = response.choices[0].message.content
print(generated_code)

Generating images from text descriptions

DALL-E 3 in Azure OpenAI generates images from text prompts. The API is different from Chat Completions — you call the images endpoint and get back a URL to the generated image.

DALL-E parameters you need to know

import os
from openai import AzureOpenAI

client = AzureOpenAI(
    azure_endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT"),
    api_key        = os.environ.get("AZURE_OPENAI_KEY"),
    api_version    = "2024-02-01"
)

# images.generate() calls the DALL-E model — different endpoint from chat.completions
# model=: the name of your DALL-E deployment (e.g. "dall-e-3")
# prompt=: text description of the image you want generated
# size=: image dimensions
# quality=: "standard" or "hd" (higher detail)
# n=: number of images (DALL-E 3 only supports n=1)
result = client.images.generate(
    model   = "dall-e-3",         # Your DALL-E deployment name
    prompt  = "A futuristic city skyline at sunset, with flying cars and neon lights, "
              "photorealistic style, ultra-high detail",
    size    = "1792x1024",         # Landscape format
    quality = "hd",               # High definition
    n       = 1                    # DALL-E 3 only generates 1 image at a time
)

# The response contains the URL of the generated image
# result.data is a list (we only have 1 image since n=1)
# .url is the temporary URL where you can download the image
# Note: DALL-E URLs expire after a short time — download and save the image promptly
image_url = result.data[0].url
print(f"Generated image URL: {image_url}")

# result.data[0].revised_prompt contains the prompt DALL-E actually used
# DALL-E 3 may revise your prompt to add safety details
revised = result.data[0].revised_prompt
print(f"Revised prompt: {revised}")

Transcribing audio to text with OpenAI's Whisper

Whisper is an OpenAI speech-to-text model available in Azure OpenAI. It transcribes audio files into text with high accuracy across 57 languages.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
    azure_endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT"),
    api_key        = os.environ.get("AZURE_OPENAI_KEY"),
    api_version    = "2024-02-01"
)

# New concept: "with open(...) as f:" — opens a file safely
# The "with" statement (from Part 1 Topic 4) ensures the file is closed
# automatically when the block finishes — even if an error occurs
# "rb" means read in binary mode (required for audio files)
with open("meeting_recording.mp3", "rb") as audio_file:

    # audio.transcriptions.create() sends the audio to Whisper for transcription
    # model=: your Whisper deployment name in Foundry
    # file=: the open audio file object
    transcription = client.audio.transcriptions.create(
        model = "whisper",          # Your Whisper deployment name
        file  = audio_file,        # The audio file to transcribe
        language = "en"           # Optional: specify language for better accuracy
    )

# .text contains the full transcription as a single string
print(f"Transcription: {transcription.text}")

Sending images to GPT-4o

GPT-4o is multimodal — it can understand images as well as text. You include image data in the user message content and the model analyses and responds to it. This is useful for image description, visual Q&A, document analysis with images, and more.

import os
import base64        # Built-in Python module for encoding binary data as text
from openai import AzureOpenAI

client = AzureOpenAI(
    azure_endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT"),
    api_key        = os.environ.get("AZURE_OPENAI_KEY"),
    api_version    = "2024-02-01"
)

# Method 1: Send image as a URL (the model downloads and reads it)
# Works if the image is publicly accessible on the internet
response_url = client.chat.completions.create(
    model = "my-gpt4o",
    messages = [
        {
            "role": "user",
            "content": [   # Content can be a LIST when combining text + images
                {
                    "type": "text",    # Text part of the message
                    "text": "What items are visible in this image? List them."
                },
                {
                    "type"    : "image_url",  # Image part of the message
                    "image_url": {
                        "url"   : "https://example.com/my-image.jpg",
                        "detail": "high"   # "high" = full resolution analysis
                                                # "low"  = faster, lower cost
                                                # "auto" = model decides
                    }
                }
            ]
        }
    ]
)
print(response_url.choices[0].message.content)


# Method 2: Send image as base64-encoded data (for private/local images)
# base64 converts binary file data into a text string safe for JSON
with open("local_image.jpg", "rb") as img_file:
    # base64.b64encode() encodes the binary image as base64 bytes
    # .decode("utf-8") converts those bytes to a regular text string
    image_data = base64.b64encode(img_file.read()).decode("utf-8")

response_b64 = client.chat.completions.create(
    model = "my-gpt4o",
    messages = [{
        "role": "user",
        "content": [
            {"type": "text", "text": "Describe this image in detail."},
            {
                "type": "image_url",
                "image_url": {
                    # data:image/jpeg;base64, tells the model this is base64 data
                    "url": f"data:image/jpeg;base64,{image_data}"
                }
            }
        ]
    }]
)
print(response_b64.choices[0].message.content)

Azure OpenAI — what the exam specifically tests

Test your understanding

5 questions — select an answer to see the explanation immediately.