Updated to use openAI SDK

GraemeMalcolm · GraemeMalcolm · commit f339ea711ea8 · 2025-07-02T14:52:07.000-07:00
diff --git a/learn-pr/wwl-data-ai/ai-foundry-sdk/06-knowledge-check.yml b/learn-pr/wwl-data-ai/ai-foundry-sdk/06-knowledge-check.yml
@@ -36,16 +36,16 @@ quiz:
     - content: "The Azure subscription ID"
       isCorrect: false
       explanation: "Incorrect. You don't need the Azure subscription ID to instantiate a AIProjectClient object"
-  - content: "Which library should you use to chat with a model that is deployed to the Azure AI model inference service?"
+  - content: "Which SDK should you use to chat with a model that is deployed in an Azure AI Foundry resource?"
     choices:
     - content: "Azure OpenAI"
-      isCorrect: false
-      explanation: "Incorrect. You can't use the Azure OpenAI library to chat with an Azure AI model inference model."
+      isCorrect: true
+      explanation: "Correct. You should use an OpenAI chat client to chat with an Azure AI model inference model."
     - content: "Azure Machine Learning"
       isCorrect: false
-      explanation: "Incorrect. You can't use the Azure Machine Learning library to chat with an Azure AI model inference model."
-    - content: "Azure AI Inference"
-      isCorrect: true
-      explanation: "Correct. Use the Azure AI Inference library to chat with an Azure AI model inference model."
+      explanation: "Incorrect. You can't use the Azure Machine Learning SDK to chat with an Azure AI model inference model."
+    - content: "Azure AI Language"
+      isCorrect: false
+      explanation: "Incorrect. the Azure AI Language SDK is used to consume Azure AI Language resources, not generayive AI models."
 
 
diff --git a/learn-pr/wwl-data-ai/ai-foundry-sdk/includes/02-azure-ai-foundry-sdk.md b/learn-pr/wwl-data-ai/ai-foundry-sdk/includes/02-azure-ai-foundry-sdk.md
@@ -13,7 +13,7 @@ The core package for working with projects in the Azure AI Foundry SDK is the **
 
 To use the Azure AI Projects library in Python, you can use the **pip** package installation utility to install the **azure-ai-projects** package from PyPi:
 
-```python
+```
 pip install azure-ai-projects
 ```
 
@@ -23,7 +23,7 @@ pip install azure-ai-projects
 
 To use the Azure AI Projects library in C#, add the **Azure.AI.Projects** package to your C# project:
 
-```csharp
+```
 dotnet add package Azure.AI.Projects --prerelease
 ```
 
@@ -87,7 +87,7 @@ var projectClient = new AIProjectClient(
 > [!NOTE]
 > The code uses the default Azure credentials to authenticate when accessing the project. To enable this authentication, in addition to the **Azure.AI.Projects** package, you need to install the **Azure.Identity** package:
 >
-> `dotnet add package Azure.Identity`
+> `dotnet add package Azure.Identity --prerelease`
 
 ::: zone-end
 
diff --git a/learn-pr/wwl-data-ai/ai-foundry-sdk/includes/04-chat-client.md b/learn-pr/wwl-data-ai/ai-foundry-sdk/includes/04-chat-client.md
@@ -1,92 +1,41 @@
-A common scenario in an AI application is to connect to a generative AI model and use *prompts* to engage in a chat-based dialog with it. You can use the Azure AI Foundry SDK to chat with models that you have deployed in your Azure AI Foundry project.
+A common scenario in an AI application is to connect to a generative AI model and use *prompts* to engage in a chat-based dialog with it.
 
-The specific libraries and code used to build a chat client depends on how the target model has been deployed in the Azure AI Foundry project. You can deploy models to the following model hosting solutions:
+While you can use the Azure OpenAI SDK, to connect "directly" to a model using key-based or Microsoft Entra ID authentication; when your model is deployed in an Azure AI Foundry project, you can also use the Azure AI Foundry SDK to retrieve a project client, from which you can then get an authenticated OpenAI chat client for any models deployed in the project's Azure AI Foundry resource. This approach makes it easy to write code that consumes models deployed in your project, switching between them easily by changing the model deployment name parameter.
 
-- **Azure AI Foundry Models**: A single endpoint for multiple models of different types, including OpenAI models and others from the Azure AI Foundry model catalog. Models are consumed through an **Azure AI Foundry** resource connection in the project (either the default **Azure AI Foundry** resource for the project or another resource connection that has been added to the project).
-- **Azure OpenAI**: A single endpoint for OpenAI models hosted in Azure. Models are consumed through an **Azure OpenAI** resource connection in the project.
-- **Serverless API**: A model-as-a-service solution in which each deployed model is accessed through a unique endpoint and hosted in the Azure AI Foundry project.
-- **Managed compute**: A model-as-a-service solution in which each deployed model is accessed through a unique endpoint hosted in custom compute.
-
-> [!NOTE]
-> To deploy models to an Azure AI model inference endpoint, you must enable the **Deploy models to Azure AI model inference service** option in Azure AI Foundry.
-
-In this module, we'll focus on models deployed to the **Azure AI Foundry Models** endpoint.
-
-## Building a client app for Azure AI Foundry Models
-
-When you have deployed models to the Azure AI model inference service, you can use the Azure AI Foundry SDK to write code that creates a **ChatCompletionsClient** object, which you can then use to chat with a deployed model. One of the benefits of using this model deployment type is that you can easily switch between deployed models by changing one parameter in your code (the model deployment name), making it a great way to test against multiple models while developing an app.
+> [!TIP]
+> You can use the OpenAI chat client provided by an Azure AI Foundry project to chat with any model deployed in the associated Azure AI Foundry resource - even non-OpenAI models, such as Microsoft Phi models.
 
 ::: zone pivot="python"
 
-The following Python code sample uses a **ChatCompletionsClient** object to chat with a model deployment named **phi-4-model**.
-
-```python
-from azure.identity import DefaultAzureCredential
-from azure.ai.inference.models import SystemMessage, UserMessage
-
-try:
-        
-    ## Get a chat client
-    inference_endpoint = f"https://{urlparse(project_endpoint).netloc}/models"
-
-    credential = DefaultAzureCredential()
-
-    chat_client = ChatCompletionsClient(
-            endpoint=inference_endpoint,
-            credential=credential,
-            credential_scopes=["https://ai.azure.com/.default"])
-    
-    # Get a chat completion based on a user-provided prompt
-    user_prompt = input("Enter a question:")
-    
-    response = chat_client.complete(
-        model="phi-4-model",
-        messages=[
-            SystemMessage("You are a helpful AI assistant that answers questions."),
-            UserMessage(user_prompt)
-        ],
-    )
-    print(response.choices[0].message.content)
-
-except Exception as ex:
-    print(ex)
-```
-
-> [!NOTE]
-> The **ChatCompletionsClient** class uses **Azure AI Inference** library. In addition to the **azure-identity** package discussed previously, the sample code shown here assumes that the **azure-ai-inference** package has been installed:
->
-> `pip install azure-ai-inference`
-
-### Using the Azure OpenAI SDK
-
-In the Azure AI Foundry SDK for Python, the **AIProjectClient** class provides a **get_azure_openai_client()** method that you can use to create an Azure OpenAI client object. You can then use the classes and methods defined in the Azure OpenAI SDK to consume an OpenAI model deployed to Azure Foundry Models.
-
-The following Python code sample uses the Azure AI Foundry and Azure OpenAI SDKs to chat with a model deployment named **gpt-4o-model**.
+The following Python code sample uses the **get_azure_openai_client()** method in the Azure AI project's **inference** operations object to get an OpenAI client with which to chat with a model that has been deployed in the project'a Azure AI Foundry resource.
 
 ```python
 from azure.identity import DefaultAzureCredential
 from azure.ai.projects import AIProjectClient
 from openai import AzureOpenAI
 
-
 try:
-    # Initialize the project client
-    project_connection_string = "https://......"
+    
+    # connect to the project
+    project_endpoint = "https://......"
     project_client = AIProjectClient(            
-        credential=DefaultAzureCredential(),
-        endpoint=project_endpoint)
-
-    ## Get an Azure OpenAI chat client
-    openai_client = project_client.inference.get_azure_openai_client(api_version="2024-10-21")
+            credential=DefaultAzureCredential(),
+            endpoint=project_endpoint,
+        )
+    
+    # Get a chat client
+    chat_client = project_client.inference.get_azure_openai_client(api_version="2024-10-21")
     
     # Get a chat completion based on a user-provided prompt
     user_prompt = input("Enter a question:")
-    response = openai_client.chat.completions.create(
-        model="gpt-4o-model",
-        messages=[
-            {"role": "system", "content": "You are a helpful AI assistant that answers questions."},
-            {"role": "user", "content": user_prompt},
+    
+    response = chat_client.complete(
+        model=model_deployment_name,
+        [
+            {"role": "system", "content": "You are a helpful AI assistant."},
+            {"role": "user", "content": user_prompt}
         ]
+        ],
     )
     print(response.choices[0].message.content)
 
@@ -103,14 +52,13 @@ except Exception as ex:
 
 ::: zone pivot="csharp"
 
-The following C# code sample uses a **ChatCompletionsClient** object to chat with a model deployment named **phi-4-model**.
+The following C# code sample uses the **GetAzureOpenAIChatClient()** method of the Azure AI project object to get an OpenAI client with which to chat with a model that has been deployed in the project'a Azure AI Foundry resource.
 
 ```csharp
-using System;
-using Azure;
-using Azure.AI.Projects;
 using Azure.Identity;
-using Azure.AI.Inference;
+using Azure.AI.Projects;
+using Azure.AI.OpenAI;
+using OpenAI.Chat;;
 
 namespace my_foundry_client
 {
@@ -127,24 +75,23 @@ namespace my_foundry_client
                     new DefaultAzureCredential());
         
                 // Get a chat client
-                ChatCompletionsClient chatClient = projectClient.GetChatCompletionsClient();
+                ChatClient chatClient = projectClient.GetAzureOpenAIChatClient(
+                    deploymentName: model_deployment, 
+                    connectionName: null,
+                    apiVersion: "2024-10-21");
         
                 // Get a chat completion based on a user-provided prompt
                 Console.WriteLine("Enter a question:");
                 var user_prompt = Console.ReadLine();
+
+                ChatCompletion completion = openaiClient.CompleteChat(
+                [
+                    new SystemChatMessage("You are a helpful AI assistant."),
+                    new UserChatMessage(user_prompt)
+                ]);
         
-                var requestOptions = new ChatCompletionsOptions()
-                {
-                    Model = "phi-4-model",
-                    Messages =
-                        {
-                            new ChatRequestSystemMessage("You are a helpful AI assistant that answers questions."),
-                            new ChatRequestUserMessage(user_prompt),
-                        }
-                };
-                
-                Response<ChatCompletions> response = chatClient.Complete(requestOptions);
-                Console.WriteLine(response.Value.Content);
+                Console.WriteLine(completion.Content[0].Text);
+
             }
             catch (Exception ex)
             {
@@ -156,9 +103,8 @@ namespace my_foundry_client
 ```
 
 > [!NOTE]
-> The **ChatCompletionsClient** class uses **Azure AI Inference** library. In addition to the **Azure.AI.Projects** and **Azure.Identity** packages discussed previously, the sample code shown here assumes that the **Azure.AI.Inference** package has been installed:
+> In addition to the **azure-ai-projects** and **azure-identity** packages discussed previously, the sample code shown here assumes that the **Azure.AI.OpenAI** package has been installed:
 >
-> `dotnet add package Azure.AI.Inference`
+> `dotnet add package Azure.AI.OpenAI --prerelease`
 
 ::: zone-end
-
