@@ -13,19 +13,26 @@ manager: nitinme
 
 # Abuse Monitoring
 
-Azure OpenAI Service detects and mitigates instances of recurring content and/or behaviors that suggest use of the service in a manner that may violate the [Code of Conduct](/legal/cognitive-services/openai/code-of-conduct?context=/azure/ai-services/openai/context/context) or other applicable product terms. Details on how data is handled can be found on the [Data, Privacy and Security page](/legal/cognitive-services/openai/data-privacy?context=/azure/ai-services/openai/context/context). Apply for modified abuse monitoring using this form: [Azure OpenAI Limited Access Review: Modified Abuse Monitoring](https://ncv.microsoft.com/3a140V2W0l).
+Azure OpenAI Service detects and mitigates instances of recurring content and/or behaviors that suggest use of the service in a manner that might violate the [Code of Conduct](/legal/cognitive-services/openai/code-of-conduct?context=/azure/ai-services/openai/context/context) or other applicable product terms. Details on how data is handled can be found on the [Data, Privacy, and Security](/legal/cognitive-services/openai/data-privacy?context=/azure/ai-services/openai/context/context) page.
 
 ## Components of abuse monitoring
 
 There are several components to abuse monitoring:
 
-- **Content Classification**: Classifier models detect harmful language and/or images in user prompts (inputs) and completions (outputs). The system looks for categories of harms as defined in the [Content Requirements](/legal/cognitive-services/openai/code-of-conduct?context=/azure/ai-services/openai/context/context), and assigns severity levels as described in more detail on the [Content Filtering page](content-filter.md).
+- **Content Classification**: Classifier models detect harmful text and/or images in user prompts (inputs) and completions (outputs). The system looks for categories of harms as defined in the [Content Requirements](/legal/cognitive-services/openai/code-of-conduct?context=/azure/ai-services/openai/context/context), and assigns severity levels as described in more detail on the [Content Filtering](/azure/ai-services/openai/concepts/content-filter) page. The content classification signals contribute to pattern detection as described below.  
+- **Abuse Pattern Capture**: Azure OpenAI Service’s abuse monitoring system looks at customer usage patterns and employs algorithms and heuristics to detect and score indicators of potential abuse. Detected patterns consider, for example, the frequency and severity at which harmful content is detected (as indicated in content classifier signals) in a customer’s prompts and completions, as well as the intentionality of the behavior. The trends and urgency of the detected pattern will also affect scoring of potential abuse severity.
+    For example, a higher volume of harmful content classified as higher severity, or recurring conduct indicating intentionality (such as recurring jailbreak attempts) are both more likely to receive a high score indicating potential abuse. 
+- **Review and Decision**: Prompts and completions that are flagged through content classification and/or identified as part of a potentially abusive pattern of use are subjected to another review process to help confirm the system’s analysis and inform actioning decisions. Such review is conducted through two methods: human review & AI review.
+    - By default, if prompts and completions are flagged through content classification as harmful and/or identified to be part of a potentially abusive pattern of use, they may be sampled for automated, eyes-off review by using an LLM instead of a human reviewer. The LLM used for this purpose processes prompts and completions only to confirm the system’s analysis and inform actioning decisions; prompts and completions that undergo such LLM review are not stored by the system or used to train the LLM or other systems.
+    - In some cases, when automated review does not meet applicable confidence thresholds in complex contexts or if LLM review systems are not available, human eyes-on review may be introduced to make an extra judgment. This can help improve the overall abuse analysis accuracy. Authorized Microsoft employees may assess flagged content, and either confirm or correct the classification or determination based on predefined guidelines and policies. Prompts and completions can be accessed for human review only by authorized Microsoft employees via Secure Access Workstations (SAWs) with Just-In-Time (JIT) request approval granted by team managers. For Azure OpenAI Service resources deployed in the European Economic Area, the authorized Microsoft employees are located in the European Economic Area. This human review process will not take place if the customer has been approved for modified abuse monitoring. 
+- **Notification and Action**: When a threshold of abusive behavior has been confirmed based on the preceding steps, the customer is informed of the determination by email. Except in cases of severe or recurring abuse, customers typically are given an opportunity to explain or remediate—and implement mechanisms to prevent recurrence of—the abusive behavior. Failure to address the behavior—or recurring or severe abuse—may result in suspension or termination of the customer’s access to Azure OpenAI resources and/or capabilities.
 
-- **Abuse Pattern Capture**: Azure OpenAI Service’s abuse monitoring looks at customer usage patterns and employs algorithms and heuristics to detect indicators of potential abuse. Detected patterns consider, for example, the frequency and severity at which harmful content is detected in a customer’s prompts and completions.
+## Modified abuse monitoring 
 
-- **Human Review and Decision**: When prompts and/or completions are flagged through content classification and abuse pattern capture as described above, authorized Microsoft employees may assess the flagged content, and either confirm or correct the classification or determination based on predefined guidelines and policies. Data can be accessed for human review <u>only</u> by authorized Microsoft employees via Secure Access Workstations (SAWs) with Just-In-Time (JIT) request approval granted by team managers. For Azure OpenAI Service resources deployed in the European Economic Area, the authorized Microsoft employees are located in the European Economic Area.
+Some customers may want to use the Azure OpenAI Service for a use case that involves the processing of highly sensitive or highly confidential data, or otherwise may conclude that they do not want or do not have the right to permit Microsoft to store and conduct human review on their prompts and completions for abuse detection. To address these concerns, Microsoft allows customers who meet additional Limited Access eligibility criteria to apply to modify abuse monitoring by completing [this ](https://customervoice.microsoft.com/Pages/ResponsePage.aspx?id=v4j5cvGGr0GRqy180BHbR7en2Ais5pxKtso_Pz4b1_xUOE9MUTFMUlpBNk5IQlZWWkcyUEpWWEhGOCQlQCN0PWcu)form. Learn more about applying for modified abuse monitoring at [Limited access to Azure OpenAI Service](/legal/cognitive-services/openai/limited-access?context=%2Fazure%2Fai-services%2Fopenai%2Fcontext%2Fcontext), and about the impact of modified abuse monitoring on data processing at [Data, privacy, and security for Azure OpenAI Service](/legal/cognitive-services/openai/data-privacy?context=%2Fazure%2Fai-services%2Fopenai%2Fcontext%2Fcontext&tabs=azure-portal).    
 
-- **Notification and Action**: When a threshold of abusive behavior has been confirmed based on the preceding three steps, the customer is informed of the determination by email. Except in cases of severe or recurring abuse, customers typically are given an opportunity to explain or remediate—and implement mechanisms to prevent recurrence of—the abusive behavior. Failure to address the behavior—or recurring or severe abuse—may result in suspension or termination of the customer’s access to Azure OpenAI resources and/or capabilities.
+> [!NOTE]
+> When abuse monitoring is modified and human review is not performed, detection of potential abuse may be less accurate. Customers will be notified of potential abuse detection as described above, and should be prepared to respond to such notification to avoid service interruption if possible.  
 
 ## Next steps
 

@@ -6,7 +6,7 @@ manager: nitinme
 ms.service: azure-ai-openai
 ms.custom: 
 ms.topic: how-to
-ms.date: 08/23/2024
+ms.date: 11/11/2024
 author: mrbullwinkle
 ms.author: mbullwin
 recommendations: false
@@ -250,7 +250,7 @@ With your commitment plan ready, the next step is to create the commitments. Com
 
 For each new commitment you need to create, follow these steps:
 
-1. Launch the Provisioned Throughput purchase dialog by selecting  **Quotas** > **Provisioned** > **Manage Commitments**.
+1. Launch the Provisioned Throughput purchase dialog by selecting  **Quota** > **Azure OpenAI Provisioned** > **Manage Commitment plans**.
 
 :::image type="content" source="../media/how-to/provisioned-onboarding/quota.png" alt-text="Screenshot of the purchase dialog." lightbox="../media/how-to/provisioned-onboarding/quota.png":::
 
@@ -301,7 +301,7 @@ Commitment renewal settings can be changed at any time before the expiration dat
 
 ## Monitor commitments and prevent unexpected billings
 
-The manage commitments pane provides a subscription wide overview of all resources with commitments and PTU usage within a given Azure Subscription. Of particular importance interest are:
+The manage commitments pane provides a subscription wide overview of all resources with commitments and PTU usage within a given Azure Subscription. Of particular importance are:
 
 - **PTUs Committed, Deployed and Usage** – These figures provide the sizes of your commitments, and how much is in use by deployments. Maximize your investment by using all of your committed PTUs.
 - **Expiration policy and date** - The expiration date and policy tell you when a commitment will expire and what will happen when it does. A commitment set to autorenew will generate a billing event on the renewal date. For commitments that are expiring, be sure you delete deployments from these resources prior to the expiration date to prevent hourly overage billingThe current renewal settings for a commitment. 

@@ -8,7 +8,7 @@ ms.service: azure-ai-openai
 ms.topic: quickstart
 author: aahill
 ms.author: aahi
-ms.date: 04/08/2024
+ms.date: 10/25/2024
 recommendations: false
 ms.custom: references_regions 
 ---
@@ -26,14 +26,14 @@ Azure OpenAI On Your Data enables you to run advanced AI models such as GPT-35-T
 :::image type="content" source="../media/use-your-data/workflow-diagram.png" alt-text="A diagram showing an example workflow.":::
 
 Typically, the development process you'd use with Azure OpenAI On Your Data is:
-1. **Ingest**: Upload files using either Azure OpenAI Studio or the ingestion API. This enables your data to be cracked, chunked and embedded into an Azure AI Search instance that can be used by Azure Open AI models. If you have an existing [supported data source](#supported-data-sources), you can also connect it directly.
+1. **Ingest**: Upload files using either Azure OpenAI Studio or the ingestion API. This enables your data to be cracked, chunked and embedded into an Azure AI Search instance that can be used by Azure OpenAI models. If you have an existing [supported data source](#supported-data-sources), you can also connect it directly.
 
 1. **Develop**: After trying Azure OpenAI On Your Data, begin developing your application using the available REST API and SDKs, which are available in several languages. It will create prompts and search intents to pass to the Azure OpenAI service.
 
 1. **Inference**: After your application is deployed in your preferred environment, it will send prompts to Azure OpenAI, which will perform several steps before returning a response:
     1. **Intent generation**: The service will determine the intent of the user's prompt to determine a proper response.
 
-    1. **Retrieval**: The service retrieves relevant chunks of available data from the connected data source by querying it. For example by using a semantic or vector search. [Parameters](#runtime-parameters) such as strictness and number of documents to retreive are utilized to influence the retrieval.
+    1. **Retrieval**: The service retrieves relevant chunks of available data from the connected data source by querying it. For example by using a semantic or vector search. [Parameters](#runtime-parameters) such as strictness and number of documents to retrieve are utilized to influence the retrieval.
     
     1. **Filtration and reranking**: Search results from the retrieval step are improved by ranking and filtering data to refine relevance.    
     
@@ -307,6 +307,55 @@ Mapping these fields correctly helps ensure the model has better response and ci
 
 Along with using Elasticsearch databases in Azure OpenAI Studio, you can also use your Elasticsearch database using the [API](../references/elasticsearch.md). 
 
+# [MongoDB Atlas (preview)](#tab/mongo-db-atlas)
+
+You can connect your MongoDB Atlas vector index with Azure OpenAI On Your Data for inferencing. You can use it through the Azure AI Studio, API and SDK.
+
+### Prerequisites 
+
+* A [MongoDB Atlas account](https://account.mongodb.com/account/register)
+* An [Azure OpenAI ada002 embedding model](./models.md#embeddings)
+    * To achieve good retrieval quality, make sure your vector index is created with Azure OpenAI ada002 embedding model.
+
+We recommend using one of the following models for MongoDB Atlas
+* gpt-4 (0613)
+* gpt-4 (turbo-2024-04-09) 
+* gpt-4o (2024-05-13) 
+* gpt-35-turbo (1106) 
+
+### Configuration  
+
+Only public network access is supported. Please make sure the database allows public access 
+:::image type="content" source="../media/use-your-data/mongo-db-network-access.png" alt-text="A screenshot showing the network access screen for Mongo DB.":::
+
+### Data preparation
+
+If you want to create a new vector search index with your documents, you can use the [available script on GitHub](https://github.com/microsoft/sample-app-aoai-chatGPT/blob/rawan/mongodbdataprep/scripts/mongo_vector_db_data_preparation.py) to prepare your data for use with Azure OpenAI On Your Data. 
+
+### Connection to MongoDB account
+
+To add your data source, you first need to create a connection to MongoDB Atlas. This connection includes information such as authentication (username and password). Enter the endpoint of your MongoDB Atlas connection string using the following format: `mongodb+srv://{user_name}:{password}@{endpoint}/?appName={application_name}`. See the [MongoDB documentation](https://aka.ms/mongodb-connection-string) for more information about connection string methods.
+
+:::image type="content" source="../media/use-your-data/mongo-db-atlas-connection.png" alt-text="A screenshot showing the connection screen for Mongo DB." lightbox="../media/use-your-data/mongo-db-atlas-connection.png":::
+
+### Source index
+
+Once you have created a connection or chosen an existing connection, you can enter the information to connect to a specific vector index within this connected account. You need to input the name of your database, collection and vector index. Make sure you have entered the information correctly to successfully build the connection.
+
+:::image type="content" source="../media/use-your-data/mongo-db-atlas-source-index.png" alt-text="A screenshot showing the field required information for Mongo DB Atlas." lightbox="../media/use-your-data/mongo-db-atlas-source-index.png":::
+
+To use MongoDB Atlas, you'll need an Azure OpenAI ada002 embedding model. This model will be created for you if you don't already have one, which will incur [usage](https://go.microsoft.com/fwlink/?linkid=2264246) on your account.
+
+### Index field mapping
+
+When you add your MongoDB Atlas data source, you can specify data fields to properly map your data for retrieval.
+
+* Content data (required): This is the main text content of each document. For multiple fields, separate the values with commas, with no spaces.
+* Vector field (required): The field name in your MongoDB Atlas search index that contains the vectors.
+* File name/title/URL: Used to display more information when a document is referenced in the chat.
+
+:::image type="content" source="../media/use-your-data/mongo-db-atlas-field-mapping.png" alt-text="A screenshot showing the field mapping options for Mongo DB Atlas." lightbox="../media/use-your-data/mongo-db-atlas-field-mapping.png":::
+
 ---
 
 ## Deploy to a copilot (preview), Teams app (preview), or web app 

@@ -36,49 +36,56 @@ Content filters can be configured at the resource level. Once a new configuratio
 You can configure the following filter categories in addition to the default harm category filters.
 
 |Filter category  |Status |Default setting  |Applied to prompt or completion?  |Description  |
-|---------|---------|---------|---------|
+|---------|---------|---------|---------|---|
 |Prompt Shields for direct attacks (jailbreak)     |GA|    On     |   User prompt      |   Filters / annotates user prompts that might present a Jailbreak Risk. For more information about annotations, visit [Azure OpenAI Service content filtering](/azure/ai-services/openai/concepts/content-filter?tabs=python#annotations-preview). |
 |Prompt Shields for indirect attacks  | GA| On| User prompt | Filter / annotate Indirect Attacks, also referred to as Indirect Prompt Attacks or Cross-Domain Prompt Injection Attacks, a potential vulnerability where third parties place malicious instructions inside of documents that the generative AI system can access and process. Required: [Document ](/azure/ai-services/openai/concepts/content-filter?tabs=warning%2Cuser-prompt%2Cpython-new#embedding-documents-in-your-prompt)formatting. |
 | Protected material - code |GA| On | Completion | Filters protected code or gets the example citation and license information in annotations for code snippets that match any public code sources, powered by GitHub Copilot. For more information about consuming annotations, see the [content filtering concepts guide](/azure/ai-services/openai/concepts/content-filter#annotations-preview) |
 | Protected material - text | GA| On | Completion | Identifies and blocks known text content from being displayed in the model output (for example, song lyrics, recipes, and selected web content).  |
+| Groundedness* | Preview |Off | Completion |Detects whether the text responses of large language models (LLMs) are grounded in the source materials provided by the users. Ungroundedness refers to instances where the LLMs produce information that is non-factual or inaccurate from what was present in the source materials. |
 
+*Requires embedding documents in your prompt. [Read more](/azure/ai-services/openai/concepts/content-filter?tabs=warning%2Cuser-prompt%2Cpython-new#embedding-documents-in-your-prompt). 
 
-## Configure content filters via Azure AI Studio
 
-The following steps show how to set up a customized content filtering configuration for your resource.
+## Configure content filters with Azure AI Studio
 
-1. Go to Azure AI Studio and navigate to the Content Filters tab (in the bottom left navigation, as designated by the red box below).
+The following steps show how to set up a customized content filtering configuration for your Azure OpenAI resource within AI Studio. For guidance with content filters in your Azure AI Studio project, you can read more at [Azure AI Studio content filtering](/azure/ai-studio/concepts/content-filtering).
 
-    :::image type="content" source="../media/content-filters/studio.png" alt-text="Screenshot of the AI Studio UI with Content Filters highlighted." lightbox="../media/content-filters/studio.png":::
+1. Go to Azure AI Studio and navigate to the **Safety + security** page on the left menu.
+1. Proceed to the **Content filters** tab and create a new customized content filtering configuration. 
 
-1. Create a new customized content filtering configuration.
+    This leads to the following configuration view, where you can choose a name for the custom content filtering configuration. After entering a name, you can configure the **input filters** (for user prompts) and **output filters** (for model completion). 
 
-   :::image type="content" source="../media/content-filters/create-filter.png" alt-text="Screenshot of the content filtering configuration UI with create selected." lightbox="../media/content-filters/create-filter.png":::
+    :::image type="content" source="../media/content-filters/input-filter.png" alt-text="Screenshot of input filter screen.":::
 
-    This leads to the following configuration view, where you can choose a name for the custom content filtering configuration. After entering a name, you can configure the **input filters** (user prompts) and **output filters** (model response). For the first four content categories there are three severity levels that are configurable: Low, medium, and high. You can use the sliders to set the severity threshold if you determine that your application or usage scenario requires different filtering than the default values. Some filters enable you to determine if the model should annotate and/or block. Selecting **Annotate** runs the respective model and return annotations via API response, but it will not filter content. In addition to annotations, you can also choose to filter content by switching the **Filter** toggle to on.
+    :::image type="content" source="../media/content-filters/output-filter.png" alt-text="Screenshot of output filter screen.":::
 
-    If your use case was approved for modified content filters as outlined above, you receive full control over content filtering configurations and can choose to turn filtering partially or fully off.
+    For the first four content categories there are three severity levels that are configurable: Low, medium, and high. You can use the sliders to set the severity threshold if you determine that your application or usage scenario requires different filtering than the default values. 
 
-    :::image type="content" source="../media/content-filters/filter-view.png" alt-text="Screenshot of the content filtering configuration UI." lightbox="../media/content-filters/filter-view.png":::
+    Some filters, such as Prompt Shields and Protected material detection, enable you to determine if the model should annotate and/or block content. Selecting **Annotate only** runs the respective model and return annotations via API response, but it will not filter content. In addition to annotate, you can also choose to block content.
 
-1. You can create multiple content filtering configurations as per your requirements.
+    If your use case was approved for modified content filters, you receive full control over content filtering configurations and can choose to turn filtering partially or fully off, or enable annotate only for the content harms categories (violence, hate, sexual and self-harm).
 
-    :::image type="content" source="../media/content-filters/multiple.png" alt-text="Screenshot of multiple content configurations in the Azure portal." lightbox="../media/content-filters/multiple.png":::
 
-1. Next, to make a custom content filtering configuration operational, assign a configuration to one or more deployments in your resource. To do this, go to the **Deployments** tab and select your deployment. Then select **Edit**.
+1. You can create multiple content filtering configurations as per your requirements.
 
-    :::image type="content" source="../media/content-filters/edit-deployment.png" alt-text="Screenshot of the content filtering configuration with edit deployment highlighted." lightbox="../media/content-filters/edit-deployment.png":::
+    :::image type="content" source="../media/content-filters/multiple.png" alt-text="Screenshot of multiple content configurations in the Azure portal." lightbox="../media/content-filters/multiple.png":::
 
+1. Next, to use a custom content filtering configuration, assign it to one or more deployments in your resource. To do this, go to the **Deployments** tab and select your deployment. Then select **Edit**.
 1. In the **Update deployment** window that appears, select your custom filter from the **Content filter** dropdown menu. Then select **Save and close** to apply the selected configuration to the deployment.
 
     :::image type="content" source="../media/content-filters/select-filter.png" alt-text="Screenshot of edit deployment configuration with content filter selected." lightbox="../media/content-filters/select-filter.png":::
 
-1. You can also edit and delete a content filter configuration if required. To do this, navigate to the content filters tab and select a configuration. Then select the desired action. You can only edit one filtering configuration at a time.  
+    You can also edit and delete a content filter configuration if required.
+    
+    Before you delete a content filtering configuration, you will need to unassign and replace it from any deployment in the **Deployments** tab.
+
+## Report content filtering feedback
+
+If you are encountering a content filtering issue, select the **Send Feedback** button at the top of the playground. This is enabled in the **Images, Chat, and Completions** playground.  
 
-    :::image type="content" source="../media/content-filters/delete.png" alt-text="Screenshot of content filter configuration with edit and delete highlighted." lightbox="../media/content-filters/delete.png":::
+When the dialog appears, select the appropriate content filtering issue. Include as much detail as possible relating to your content filtering issue, such as the specific prompt and content filtering error you encountered. Do not include any private or sensitive information. 
 
-    > [!NOTE]
-    > Before deleting a content filtering configuration, you will need to unassign it from any deployment in the Deployments tab.
+For support, please [submit a support ticket](https://ms.portal.azure.com/#view/Microsoft_Azure_Support/HelpAndSupportBlade/~/overview). 
 
 ## Follow best practices
 

@@ -32,6 +32,7 @@ Data zone deployments leverage Azure's global infrastructure to dynamically rout
 
 If the Azure OpenAI resource used in your Data Zone deployment is located in the United States, the data will be processed within the United States. If the Azure OpenAI resource used in your Data Zone deployment is located in a European Union Member Nation, the data will be processed within the European Union Member Nation geographies. For all Azure OpenAI service deployment types, any data stored at rest will continue to remain in the geography of the Azure OpenAI resource. Azure data processing and compliance commitments remain applicable.
 
+For any [deployment type](/azure/ai-services/openai/how-to/deployment-types) labeled 'Global,' prompts and responses may be processed in any geography where the relevant Azure OpenAI model is deployed (learn more about [region availability of models](/azure/ai-services/openai/concepts/models#model-summary-table-and-region-availability)). For any deployment type labeled as 'DataZone,' prompts and responses may be processed in any geography within the specified data zone, as defined by Microsoft. If you create a DataZone deployment in an Azure OpenAI resource located in the United States, prompts and responses may be processed anywhere within the United States. If you create a DataZone deployment in an Azure OpenAI resource located in a European Union Member Nation, prompts and responses may be processed in that or any other European Union Member Nation. For both Global and DataZone deployment types, any data stored at rest, such as uploaded data, is stored in the customer-designated geography. Only the location of processing is affected when a customer uses a Global deployment type or DataZone deployment type in Azure OpenAI Service; Azure data processing and compliance commitments remain applicable.
 ## Deployment types
 
 Azure OpenAI offers three types of deployments. These provide a varied level of capabilities that provide trade-offs on: throughput, SLAs, and price. Below is a summary of the options followed by a deeper description of each.

@@ -0,0 +1,499 @@
+---
+title: How to migrate from Azure.AI.OpenAI 1.0 Beta to 2.0
+titleSuffix: Azure OpenAI Service
+description: Learn about migrating to the latest release of the Azure OpenAI package for .NET.
+author: mrbullwinkle 
+ms.author: mbullwin 
+ms.service: azure-ai-openai
+ms.custom: devx-track-dotnet
+ms.topic: how-to
+ms.date: 11/19/2024
+manager: nitinme
+---
+
+# Migrate from 1.0 beta to 2.0 (`Azure.AI.OpenAI`)
+
+> [!NOTE]
+> This guide describes how to migrate an application that previously used a 1.0 beta version of the `Azure.AI.OpenAI` library to use the new 2.0 library.
+> For general guidance on using `OpenAI` and `Azure.AI.OpenAI` features, see [the OpenAI README](https://github.com/openai/openai-dotnet/blob/main/README.md) or [the Azure.AI.OpenAI README](https://github.com/Azure/azure-sdk-for-net/blob/main/sdk/openai/Azure.AI.OpenAI/README.md).
+
+## Setup
+
+Stable releases of `Azure.AI.OpenAI` are associated with a corresponding stable Azure OpenAI Service API version label, for example, `2024-10-21`.
+
+```dotnetcli
+dotnet add package Azure.AI.OpenAI
+```
+
+Beta releases of `Azure.AI.OpenAI` are associated with a corresponding preview Azure OpenAI Service API version label, for example, `2024-10-01-preview`.
+
+```dotnetcli
+dotnet add package Azure.AI.OpenAI --prerelease
+```
+
+## Client configuration
+
+Although client instantiation is similar to 1.0, 2.0 introduces a distinct, Azure-specific top-level client that individual scenario clients are retrieved from.
+
+# [Azure.AI.OpenAI 1.0 Beta](#tab/beta)
+
+```csharp
+// 1.0 - BEFORE: Getting a general-purpose client ready for use in 1.0
+OpenAIClient client = new(
+    new Uri("https://your-resource.openai.azure.com/"),
+    new AzureKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY"));
+```
+
+# [Azure.AI.OpenAI 2.0](#tab/stable)
+
+```csharp
+// 2.0 - NEW: Get a chat completions client from a top-level Azure client
+AzureOpenAIClient azureClient = new(
+    new Uri("https://your-resource.openai.azure.com/"),
+    new AzureKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY"));
+ChatClient chatClient = azureClient.GetChatClient("my-gpt-4o-mini-deployment");
+```
+
+Just like in 1.0, the new `AzureOpenAIClient` supports the use of Microsoft Entra ID credentials when the [Azure.Identity](/dotnet/api/overview/azure/identity-readme?view=azure-dotnet&preserve-view=true) package is installed.
+
+```csharp
+// 2.0: Microsoft Entra ID via Azure.Identity's DefaultAzureCredential
+string endpoint = "https://myaccount.openai.azure.com/";
+AzureOpenAIClient client = new(new Uri(endpoint), new DefaultAzureCredential());
+```
+
+---
+
+## Chat completion
+
+# [Azure.AI.OpenAI 1.0 Beta](#tab/beta)
+
+```csharp
+// 1.0 - BEFORE
+OpenAIClient client = new(azureOpenAIResourceUri, azureOpenAIApiKey);
+
+var chatCompletionsOptions = new ChatCompletionsOptions()
+{
+    DeploymentName = "gpt-3.5-turbo", // Use DeploymentName for "model" with non-Azure clients
+    Messages =
+    {
+        // The system message represents instructions or other guidance about how the assistant should behave
+        new ChatRequestSystemMessage("You are a helpful assistant. You will talk like a pirate."),
+        // User messages represent current or historical input from the end user
+        new ChatRequestUserMessage("Can you help me?"),
+        // Assistant messages represent historical responses from the assistant
+        new ChatRequestAssistantMessage("Arrrr! Of course, me hearty! What can I do for ye?"),
+        new ChatRequestUserMessage("What's the best way to train a parrot?"),
+    }
+};
+```
+
+# [Azure.AI.OpenAI 2.0](#tab/stable)
+
+```csharp
+// 2.0 - NEW
+ChatClient chatClient = aoaiClient.GetChatClient("my-gpt-4o-mini-deployment");
+
+ChatCompletion completion = chatClient.CompleteChat(
+    [
+        // System messages represent instructions or other guidance about how the assistant should behave
+        new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
+        // User messages represent user input, whether historical or the most recent input
+        new UserChatMessage("Hi, can you help me?"),
+        // Assistant messages in a request represent conversation history for responses
+        new AssistantChatMessage("Arrr! Of course, me hearty! What can I do for ye?"),
+        new UserChatMessage("What's the best way to train a parrot?"),
+    ]);
+```
+
+---
+
+Consuming chat completions response is simplified in 2.0.
+
+# [Azure.AI.OpenAI 1.0 Beta](#tab/beta)
+
+```csharp
+// 1.0 - BEFORE:
+Response<ChatCompletions> response = await client.GetChatCompletionsAsync(chatCompletionsOptions);
+ChatResponseMessage responseMessage = response.Value.Choices[0].Message;
+Console.WriteLine($"[{responseMessage.Role.ToString().ToUpperInvariant()}]: {responseMessage.Content}");
+```
+
+# [Azure.AI.OpenAI 2.0](#tab/stable)
+
+```csharp
+// 2.0 - NEW:
+ChatCompletion completion = await chatClient.CompleteChatAsync(messages);
+Console.WriteLine($"{completion.Role}: {completion.Content[0].Text}");
+```
+
+---
+
+### Streaming
+
+# [Azure.AI.OpenAI 1.0 Beta](#tab/beta)
+
+```csharp
+// 1.0 - BEFORE
+await foreach (StreamingChatCompletionsUpdate chatUpdate in client.GetChatCompletionsStreaming(chatCompletionsOptions))
+{
+    if (chatUpdate.Role.HasValue)
+    {
+        Console.Write($"{chatUpdate.Role.Value.ToString().ToUpperInvariant()}: ");
+    }
+    if (!string.IsNullOrEmpty(chatUpdate.ContentUpdate))
+    {
+        Console.Write(chatUpdate.ContentUpdate);
+    }
+}
+```
+
+# [Azure.AI.OpenAI 2.0](#tab/stable)
+
+```csharp
+// 2.0 - NEW
+AsyncCollectionResult<StreamingChatCompletionUpdate> completionUpdates
+  = await chatClient.CompleteChatStreamingAsync(messages);
+
+foreach (StreamingChatCompletionUpdate completionUpdate in completionUpdates)
+{
+    foreach (ChatMessageContentPart contentPart in completionUpdate.ContentUpdate)
+    {
+        Console.Write(contentPart.Text);
+    }
+}
+```
+
+---
+
+### Tool definitions
+
+# [Azure.AI.OpenAI 1.0 Beta](#tab/beta)
+
+```csharp
+// 1.0 - BEFORE
+var getWeatherTool = new ChatCompletionsFunctionToolDefinition()
+{
+    Name = "get_current_weather",
+    Description = "Get the current weather in a given location",
+    Parameters = BinaryData.FromObjectAsJson(
+    new
+    {
+        Type = "object",
+        Properties = new
+        {
+            Location = new
+            {
+                Type = "string",
+                Description = "The city and state, e.g. San Francisco, CA",
+            },
+            Unit = new
+            {
+                Type = "string",
+                Enum = new[] { "celsius", "fahrenheit" },
+            }
+        },
+        Required = new[] { "location" },
+    },
+    new JsonSerializerOptions() {  PropertyNamingPolicy = JsonNamingPolicy.CamelCase }),
+};
+
+var chatCompletionsOptions = new ChatCompletionsOptions()
+{
+    DeploymentName = "gpt-35-turbo-1106",
+    Messages = { new ChatRequestUserMessage("What's the weather like in Boston?") },
+    Tools = { getWeatherTool },
+};
+
+Response<ChatCompletions> response = await client.GetChatCompletionsAsync(chatCompletionsOptions);
+```
+
+# [Azure.AI.OpenAI 2.0](#tab/stable)
+
+```csharp
+// 2.0 - NEW
+ChatTool getCurrentWeatherTool = ChatTool.CreateFunctionTool(
+    functionName: nameof(GetCurrentWeather),
+    functionDescription: "Get the current weather in a given location",
+    functionParameters: BinaryData.FromString("""
+    {
+        "type": "object",
+        "properties": {
+            "location": {
+                "type": "string",
+                "description": "The city and state, e.g. Boston, MA"
+            },
+            "unit": {
+                "type": "string",
+                "enum": [ "celsius", "fahrenheit" ],
+                "description": "The temperature unit to use. Infer this from the specified location."
+            }
+        },
+        "required": [ "location" ]
+    }
+    """)
+);
+
+ChatCompletionOptions options = new()
+{
+    Tools = { getCurrentWeatherTool },
+};
+
+ChatCompletion completion = await chatClient.CompleteChatAsync(
+    ["What's the weather like Boston?"],
+    options);
+```
+
+---
+
+### Handling tool call responses
+
+# [Azure.AI.OpenAI 1.0 Beta](#tab/beta)
+
+```csharp
+// 1.0 - BEFORE
+var chatCompletionsOptions = new ChatCompletionsOptions()
+{
+    DeploymentName = "gpt-35-turbo-1106",
+    Messages = { new ChatRequestUserMessage("What's the weather like in Boston?") },
+    Tools = { getWeatherTool },
+};
+
+Response<ChatCompletions> response = await client.GetChatCompletionsAsync(chatCompletionsOptions);
+```
+
+# [Azure.AI.OpenAI 2.0](#tab/stable)
+
+```csharp
+// 2.0 - NEW
+if (completion.FinishReason == ChatFinishReason.ToolCalls)
+{
+    // Add a new assistant message to the conversation history that includes the tool calls
+    conversationMessages.Add(new AssistantChatMessage(completion));
+
+    foreach (ChatToolCall toolCall in completion.ToolCalls)
+    {
+        conversationMessages.Add(new ToolChatMessage(toolCall.Id, GetToolCallContent(toolCall)));
+    }
+
+    // Now make a new request with all the messages thus far, including the original
+}
+```
+
+---
+
+## Chat with On Your Data
+
+# [Azure.AI.OpenAI 1.0 Beta](#tab/beta)
+
+```csharp
+// 1.0 - BEFORE
+AzureSearchChatExtensionConfiguration contosoExtensionConfig = new()
+{
+    SearchEndpoint = new Uri("https://your-contoso-search-resource.search.windows.net"),
+    Authentication = new OnYourDataApiKeyAuthenticationOptions("<your Cognitive Search resource API key>"),
+};
+
+ChatCompletionsOptions chatCompletionsOptions = new()
+{
+    DeploymentName = "gpt-35-turbo-0613",
+    Messages =
+    {
+        new ChatRequestSystemMessage(
+            "You are a helpful assistant that answers questions about the Contoso product database."),
+        new ChatRequestUserMessage("What are the best-selling Contoso products this month?")
+    },
+
+    // The addition of AzureChatExtensionsOptions enables the use of Azure OpenAI capabilities that add to
+    // the behavior of Chat Completions, here the "using your own data" feature to supplement the context
+    // with information from an Azure Cognitive Search resource with documents that have been indexed.
+    AzureExtensionsOptions = new AzureChatExtensionsOptions()
+    {
+        Extensions = { contosoExtensionConfig }
+    }
+};
+
+Response<ChatCompletions> response = await client.GetChatCompletionsAsync(chatCompletionsOptions);
+```
+
+# [Azure.AI.OpenAI 2.0](#tab/stable)
+
+```csharp
+// 2.0 - NEW
+// Extension methods to use data sources with options are subject to SDK surface changes. Suppress the
+// warning to acknowledge and this and use the subject-to-change AddDataSource method.
+#pragma warning disable AOAI001
+
+ChatCompletionOptions options = new();
+options.AddDataSource(new AzureSearchChatDataSource()
+{
+    Endpoint = new Uri("https://your-search-resource.search.windows.net"),
+    IndexName = "contoso-products-index",
+    Authentication = DataSourceAuthentication.FromApiKey(
+        Environment.GetEnvironmentVariable("OYD_SEARCH_KEY")),
+});
+
+ChatCompletion completion = chatClient.CompleteChat(
+    [
+        new UserChatMessage("What are the best-selling Contoso products this month?"),
+    ],
+    options);
+
+ChatMessageContext onYourDataContext = completion.GetMessageContext();
+
+if (onYourDataContext?.Intent is not null)
+{
+    Console.WriteLine($"Intent: {onYourDataContext.Intent}");
+}
+foreach (ChatCitation citation in onYourDataContext?.Citations ?? [])
+{
+    Console.WriteLine($"Citation: {citation.Content}");
+}
+```
+
+---
+
+## Embeddings
+
+# [Azure.AI.OpenAI 1.0 Beta](#tab/beta)
+
+```csharp
+// 1.0 - BEFORE
+EmbeddingsOptions embeddingsOptions = new()
+{
+    DeploymentName = "text-embedding-ada-002",
+    Input = { "Your text string goes here" },
+};
+Response<Embeddings> response = await client.GetEmbeddingsAsync(embeddingsOptions);
+
+// The response includes the generated embedding.
+EmbeddingItem item = response.Value.Data[0];
+ReadOnlyMemory<float> embedding = item.Embedding;
+```
+
+# [Azure.AI.OpenAI 2.0](#tab/stable)
+
+
+```csharp
+// 2.0 - NEW
+EmbeddingClient client = aoaiClient.GetEmbeddingClient("text-embedding-3-small");
+
+string description = "Best hotel in town if you like luxury hotels. They have an amazing infinity pool, a spa,"
+    + " and a really helpful concierge. The location is perfect -- right downtown, close to all the tourist"
+    + " attractions. We highly recommend this hotel.";
+
+OpenAIEmbedding embedding = client.GenerateEmbedding(description);
+ReadOnlyMemory<float> vector = embedding.ToFloats();
+```
+
+---
+
+## Image generation
+
+# [Azure.AI.OpenAI 1.0 Beta](#tab/beta)
+
+```csharp
+// 1.0 - BEFORE
+Response<ImageGenerations> response = await client.GetImageGenerationsAsync(
+    new ImageGenerationOptions()
+    {
+        DeploymentName = usingAzure ? "my-azure-openai-dall-e-3-deployment" : "dall-e-3",
+        Prompt = "a happy monkey eating a banana, in watercolor",
+        Size = ImageSize.Size1024x1024,
+        Quality = ImageGenerationQuality.Standard
+    });
+
+ImageGenerationData generatedImage = response.Value.Data[0];
+if (!string.IsNullOrEmpty(generatedImage.RevisedPrompt))
+{
+    Console.WriteLine($"Input prompt automatically revised to: {generatedImage.RevisedPrompt}");
+}
+Console.WriteLine($"Generated image available at: {generatedImage.Url.AbsoluteUri}");
+```
+
+# [Azure.AI.OpenAI 2.0](#tab/stable)
+
+```csharp
+// 2.0 - NEW
+ImageClient imageClient = aoaiClient.GetImageClient("my-dall-e-3-deployment");
+
+string prompt = "The concept for a living room that blends Scandinavian simplicity with Japanese minimalism for"
+    + " a serene and cozy atmosphere. It's a space that invites relaxation and mindfulness, with natural light"
+    + " and fresh air. Using neutral tones, including colors like white, beige, gray, and black, that create a"
+    + " sense of harmony. Featuring sleek wood furniture with clean lines and subtle curves to add warmth and"
+    + " elegance. Plants and flowers in ceramic pots adding color and life to a space. They can serve as focal"
+    + " points, creating a connection with nature. Soft textiles and cushions in organic fabrics adding comfort"
+    + " and softness to a space. They can serve as accents, adding contrast and texture.";
+
+ImageGenerationOptions options = new()
+{
+    Quality = GeneratedImageQuality.High,
+    Size = GeneratedImageSize.W1792xH1024,
+    Style = GeneratedImageStyle.Vivid,
+    ResponseFormat = GeneratedImageFormat.Bytes
+};
+
+GeneratedImage image = imageClient.GenerateImage(prompt, options);
+BinaryData bytes = image.ImageBytes;
+```
+
+---
+
+## Audio transcription
+
+# [Azure.AI.OpenAI 1.0 Beta](#tab/beta)
+
+```csharp
+// 1.0 - BEFORE
+using Stream audioStreamFromFile = File.OpenRead("myAudioFile.mp3");
+
+var transcriptionOptions = new AudioTranscriptionOptions()
+{
+    DeploymentName = "my-whisper-deployment", // whisper-1 as model name for non-Azure OpenAI
+    AudioData = BinaryData.FromStream(audioStreamFromFile),
+    Filename = "test.mp3",
+    ResponseFormat = AudioTranscriptionFormat.Verbose,
+};
+
+Response<AudioTranscription> transcriptionResponse
+    = await client.GetAudioTranscriptionAsync(transcriptionOptions);
+AudioTranscription transcription = transcriptionResponse.Value;
+
+// When using Simple, SRT, or VTT formats, only transcription.Text will be populated
+Console.WriteLine($"Transcription ({transcription.Duration.Value.TotalSeconds}s):");
+Console.WriteLine(transcription.Text);
+```
+
+# [Azure.AI.OpenAI 2.0](#tab/stable)
+
+```csharp
+// 2.0 - NEW
+AudioClient client = aoaiClient.GetAudioClient("my-whisper-1-deployment");
+
+AudioTranscriptionOptions options = new()
+{
+    ResponseFormat = AudioTranscriptionFormat.Verbose,
+    TimestampGranularities = AudioTimestampGranularities.Word | AudioTimestampGranularities.Segment,
+};
+
+AudioTranscription transcription = client.TranscribeAudio("my_audio_file.mp3", options);
+
+Console.WriteLine("Transcription:");
+Console.WriteLine($"{transcription.Text}");
+
+Console.WriteLine();
+Console.WriteLine($"Words:");
+foreach (TranscribedWord word in transcription.Words)
+{
+    Console.WriteLine($"  {word.Word,15} : {word.StartTime.TotalMilliseconds,5:0} - {word.EndTime.TotalMilliseconds,5:0}");
+}
+
+Console.WriteLine();
+Console.WriteLine($"Segments:");
+foreach (TranscribedSegment segment in transcription.Segments)
+{
+    Console.WriteLine($"  {segment.Text,90} : {segment.StartTime.TotalMilliseconds,5:0} - {segment.EndTime.TotalMilliseconds,5:0}");
+}
+```
+
+---
\ No newline at end of file

@@ -0,0 +1,324 @@
+---
+title: 'How to use Azure OpenAI Service evaluation'
+titleSuffix: Azure OpenAI
+description: Learn how to use evaluations with Azure OpenAI
+manager: nitinme
+ms.service: azure-ai-openai
+ms.topic: how-to
+ms.custom: references_regions
+ms.date: 11/10/2024
+author: mrbullwinkle
+ms.author: mbullwin
+recommendations: false
+---
+
+# Azure OpenAI Evaluation (Preview)
+
+The evaluation of large language models is a critical step in measuring their performance across various tasks and dimensions. This is especially important for fine-tuned models, where assessing the performance gains (or losses) from training is crucial. Thorough evaluations can help your understanding of how different versions of the model may impact your application or scenario.
+
+Azure OpenAI evaluation enables developers to create evaluation runs to test against expected input/output pairs, assessing the model’s performance across key metrics such as accuracy, reliability, and overall performance.
+
+## Evaluations support
+
+### Regional availability
+
+- North Central US
+- Sweden Central
+- Switzerland West
+
+### Supported deployment types
+
+- Standard
+- Provisioned
+
+## Evaluation pipeline
+
+### Test data
+
+You need to assemble a ground truth dataset that you want to test against. Dataset creation is typically an iterative process that ensures your evaluations remain relevant to your scenarios over time. This ground truth dataset is typically handcrafted and represents the expected behavior from your model. The dataset is also labeled and includes the expected answers.
+
+> [!NOTE]
+> Some evaluation tests like **Sentiment** and **valid JSON or XML** do not require ground truth data.
+
+Your data source needs to be in JSONL format. Below are two examples of the JSONL evaluation datasets:
+
+### Evaluation format
+
+# [Question & Answer Evaluation](#tab/question-eval-input)
+
+```jsonl
+{"question": "Find the degree for the given field extension Q(sqrt(2), sqrt(3), sqrt(18)) over Q.", "subject": "abstract_algebra", "A": "0", "B": "4", "C": "2", "D": "6", "answer": "B", "completion": "B"}
+{"question": "Let p = (1, 2, 5, 4)(2, 3) in S_5 . Find the index of <p> in S_5.", "subject": "abstract_algebra", "A": "8", "B": "2", "C": "24", "D": "120", "answer": "C", "completion": "C"}
+{"question": "Find all zeros in the indicated finite field of the given polynomial with coefficients in that field. x^5 + 3x^3 + x^2 + 2x in Z_5", "subject": "abstract_algebra", "A": "0", "B": "1", "C": "0,1", "D": "0,4", "answer": "D", "completion": "D"}
+```
+
+When you upload and select your evaluation file a preview of the first three lines will be returned:
+
+:::image type="content" source="../media/how-to/evaluations/question-input.png" alt-text="Screenshot that shows a preview of an uploaded evaluation training file for question and answer pairs." lightbox="../media/how-to/evaluations/question-input.png":::
+
+# [Chat Completions](#tab/summarization-input)
+
+```jsonl
+{"input": [{"role": "system", "content": "Provide a clear and concise summary of the technical content, highlighting key concepts and their relationships. Focus on the main ideas and practical implications."}, {"role": "user", "content": "Tokenization is a key step in preprocessing for natural language processing, involving the division of text into smaller components called tokens. These can be words, subwords, or characters, depending on the method chosen. Word tokenization divides text at word boundaries, while subword techniques like Byte Pair Encoding (BPE) or WordPiece can manage unknown words by breaking them into subunits. Character tokenization splits text into individual characters, useful for multiple languages and misspellings. The tokenization method chosen greatly affects model performance and its capacity to handle various languages and vocabularies."}], "output": "Tokenization divides text into smaller units (tokens) for NLP applications, using word, subword (e.g., BPE), or character methods. Each has unique benefits, impacting model performance and language processing capabilities."}      
+{"input": [{"role": "system", "content": "Create a comprehensive yet concise summary that captures the essential technical details and significance of the topic."}, {"role": "user", "content": "Self-attention mechanisms are vital in modern transformer models, allowing them to evaluate the relevance of different parts of an input sequence when processing each element. In self-attention, each position in a sequence learns to focus on all other positions, forming a weighted sum of their values. Attention weights are derived using queries, keys, and values, with compatibility between a query and key determining attention to each value. This mechanism enables capturing long-range dependencies and relationships within a sequence, making it effective for tasks needing context understanding and inter-part relationships."}], "output": "Self-attention is crucial in transformers, enabling each sequence position to evaluate and collect data from all others. It uses queries, keys, and values for attention weights, effectively capturing long-range dependencies and contextual links."}      
+{"input": [{"role": "system", "content": "Synthesize the technical information into a brief, accurate summary that maintains the core concepts and their significance."}, {"role": "user", "content": "The transformer architecture significantly changed natural language processing by introducing a new method for sequence processing. Unlike recurrent neural networks, transformers process whole sequences at once using self-attention. The architecture consists of an encoder and decoder, each with multiple layers of multi-head attention, feed-forward networks, and normalization layers. The encoder processes the input sequence, and the decoder produces the output sequence. Positional encodings are added to retain sequence order information since the model lacks inherent sequence position awareness. This architecture underlies many leading language models like BERT and GPT."}], "output": "Transformers are a transformative neural architecture processing sequences with self-attention instead of recurrence. Their encoder-decoder design, with multi-head attention and position encodings, is fundamental to modern language models like BERT and GPT."}      
+```
+
+When you upload and select you evaluation file a preview of the first three lines will be returned:
+
+:::image type="content" source="../media/how-to/evaluations/summarization-input.png" alt-text="Screenshot that shows a preview of an uploaded evaluation training file for summarization tasks." lightbox="../media/how-to/evaluations/summarization-input.png":::
+
+---
+
+You can choose any existing previously uploaded datasets, or upload a new dataset.
+
+### Generate responses (optional)
+
+The prompt you use in your evaluation should match the prompt you plan to use in production. These prompts provide the instructions for the model to follow. Similar to the playground experiences, you can create multiple inputs to include few-shot examples in your prompt. For more information, see [prompt engineering techniques](../concepts/advanced-prompt-engineering.md) for details on some advanced techniques in prompt design and prompt engineering.
+
+You can reference your input data within the prompts by using the `{{input.column_name}}` format, where column_name corresponds to the names of the columns in your input file.
+
+Outputs generated during the evaluation will be referenced in subsequent steps using the `{{sample.output_text}}` format. 
+
+> [!NOTE]
+> You need to use double curly braces to make sure you reference to your data correctly.
+
+### Model deployment
+
+As part of creating evaluations you'll pick which models to use when generating responses (optional) as well as which models to use when grading models with specific testing criteria.  
+
+In Azure OpenAI you'll be assigning specific model deployments to use as part of your evaluations. You can compare multiple deployments by creating a separate evaluation configuration for each model. This enables you to define specific prompts for each evaluation, providing better control over the variations required by different models.
+
+You can evaluate either a base or a fine-tuned model deployment. The deployments available in your list depend on those you created within your Azure OpenAI resource. If you can't find the desired deployment, you can create a new one from the Azure OpenAI Evaluation page.
+
+### Testing criteria
+
+Testing criteria is used to assess the effectiveness of each output generated by the target model. These tests compare the input data with the output data to ensure consistency. You have the flexibility to configure different criteria to test and measure the quality and relevance of the output at different levels.
+
+:::image type="content" source="../media/how-to/evaluations/testing-criteria.png" alt-text="Screenshot that shows the evaluations testing criteria options." lightbox="../media/how-to/evaluations/testing-criteria.png":::
+
+## Getting started
+
+1. Select the **Azure OpenAI Evaluation (PREVIEW)** within Azure AI Studio. To see this view as an option may need to first select an existing Azure OpenAI resource in a supported region.
+2. Select **New evaluation**
+
+    :::image type="content" source="../media/how-to/evaluations/new-evaluation.png" alt-text="Screenshot of the Azure OpenAI evaluation UX with new evaluation selected." lightbox="../media/how-to/evaluations/new-evaluation.png":::
+
+3. Enter a name of your evaluation. By default a random name is automatically generated unless you edit and replace it. > select **Upload new dataset**.
+
+    :::image type="content" source="../media/how-to/evaluations/upload.png" alt-text="Screenshot of the Azure OpenAI upload UX." lightbox="../media/how-to/evaluations/upload.png":::
+
+4. Select your evaluation which will be in `.jsonl` format. If you need a sample test file you can save these 10 lines to a file called `eval-test.jsonl`:
+
+    ```jsonl
+    {"input": [{"role": "system", "content": "Provide a clear and concise summary of the technical content, highlighting key concepts and their relationships. Focus on the main ideas and practical implications."}, {"role": "user", "content": "Tokenization is a key step in preprocessing for natural language processing, involving the division of text into smaller components called tokens. These can be words, subwords, or characters, depending on the method chosen. Word tokenization divides text at word boundaries, while subword techniques like Byte Pair Encoding (BPE) or WordPiece can manage unknown words by breaking them into subunits. Character tokenization splits text into individual characters, useful for multiple languages and misspellings. The tokenization method chosen greatly affects model performance and its capacity to handle various languages and vocabularies."}], "output": "Tokenization divides text into smaller units (tokens) for NLP applications, using word, subword (e.g., BPE), or character methods. Each has unique benefits, impacting model performance and language processing capabilities."}      
+    {"input": [{"role": "system", "content": "Create a comprehensive yet concise summary that captures the essential technical details and significance of the topic."}, {"role": "user", "content": "Self-attention mechanisms are vital in modern transformer models, allowing them to evaluate the relevance of different parts of an input sequence when processing each element. In self-attention, each position in a sequence learns to focus on all other positions, forming a weighted sum of their values. Attention weights are derived using queries, keys, and values, with compatibility between a query and key determining attention to each value. This mechanism enables capturing long-range dependencies and relationships within a sequence, making it effective for tasks needing context understanding and inter-part relationships."}], "output": "Self-attention is crucial in transformers, enabling each sequence position to evaluate and collect data from all others. It uses queries, keys, and values for attention weights, effectively capturing long-range dependencies and contextual links."}      
+    {"input": [{"role": "system", "content": "Synthesize the technical information into a brief, accurate summary that maintains the core concepts and their significance."}, {"role": "user", "content": "The transformer architecture significantly changed natural language processing by introducing a new method for sequence processing. Unlike recurrent neural networks, transformers process whole sequences at once using self-attention. The architecture consists of an encoder and decoder, each with multiple layers of multi-head attention, feed-forward networks, and normalization layers. The encoder processes the input sequence, and the decoder produces the output sequence. Positional encodings are added to retain sequence order information since the model lacks inherent sequence position awareness. This architecture underlies many leading language models like BERT and GPT."}], "output": "Transformers are a transformative neural architecture processing sequences with self-attention instead of recurrence. Their encoder-decoder design, with multi-head attention and position encodings, is fundamental to modern language models like BERT and GPT."}      
+    {"input": [{"role": "system", "content": "Distill the technical content into a clear, concise summary that preserves the most important concepts and their practical applications."}, {"role": "user", "content": "Cosine similarity is a metric for measuring similarity between vectors by calculating the cosine of the angle between them. The outcome ranges from -1 to 1, with 1 indicating identical orientation, 0 orthogonality, and -1 opposite orientation. In machine learning and NLP, cosine similarity is useful for comparing document vectors, word embeddings, or any high-dimensional representations. It's often preferred over Euclidean distance because it's invariant to vector magnitude, focusing instead on orientation. This makes it particularly useful for comparing documents or embeddings of various lengths or scales."}], "output": "Cosine similarity evaluates vector similarity by computing their angle's cosine, with values from -1 to 1. It's widely used in ML and NLP for comparing document vectors and embeddings due to its magnitude-invariant nature."}      
+    {"input": [{"role": "system", "content": "Provide a succinct summary that captures the key technical concepts and their relationships while maintaining clarity and accuracy."}, {"role": "user", "content": "Neural network activation functions are crucial for introducing non-linearity to deep learning models. Commonly used activation functions include ReLU (Rectified Linear Unit), which outputs the input directly if positive and zero otherwise, sigmoid, which compresses values between 0 and 1, and tanh, which normalizes values between -1 and 1. Each function has specific benefits and applications: ReLU avoids vanishing gradients and enables sparse activation, sigmoid is useful for binary classification, and tanh is often used in hidden layers for its zero-centered output. The activation function choice greatly affects model training dynamics and ultimate performance."}], "output": "Activation functions introduce non-linearity to neural networks, with ReLU, sigmoid, and tanh being the most common. Each serves distinct purposes: ReLU prevents vanishing gradients, sigmoid is suitable for binary classification, and tanh offers zero-centered output, all affecting model performance differently."}      
+    {"input": [{"role": "system", "content": "Create a focused summary that emphasizes the main technical concepts and their practical implications while maintaining accuracy."}, {"role": "user", "content": "Batch normalization is a technique that stabilizes and accelerates deep neural network training by normalizing each layer's inputs. It normalizes activations using the mean and variance computed over the current data batch. This normalization reduces internal covariate shift, where the input distribution changes during training. Batch normalization includes learnable parameters (gamma and beta) allowing the network to reverse normalization if necessary. Benefits include enabling higher learning rates, lessening the importance of precise parameter initialization, and serving as a regularizer, potentially removing the need for dropout."}], "output": "Batch normalization stabilizes neural network training by normalizing layer inputs using batch statistics. It addresses internal covariate shift with learnable parameters, allowing higher learning rates and improved training dynamics, while offering regularization benefits."}      
+    {"input": [{"role": "system", "content": "Summarize the technical content while preserving the essential concepts and their interconnections, ensuring clarity and precision."}, {"role": "user", "content": "Gradient descent optimization algorithms are foundational to training machine learning models. The basic version updates parameters in the steepest descent direction of the loss function. Variants like Stochastic Gradient Descent (SGD) use random samples to estimate gradients, enhancing computational efficiency. Advanced optimizers like Adam combine momentum (helping overcome local minima) and RMSprop (adapting learning rates for each parameter). These optimizers maintain running averages of gradients and their squares, enabling adaptive learning rates and more efficient training. The optimizer choice can significantly influence model convergence speed and final performance."}], "output": "Gradient descent algorithms optimize ML models by updating parameters based on loss gradients. Variants like SGD use sampling for efficiency, while advanced optimizers like Adam combine momentum with adaptive learning rates for improved training performance."}      
+    {"input": [{"role": "system", "content": "Deliver a concise yet comprehensive summary that highlights the key technical aspects and their practical significance."}, {"role": "user", "content": "Cross-validation is a resampling method used to evaluate machine learning models on limited data. The most common form, k-fold cross-validation, involves dividing the dataset into k equal parts, training the model on k-1 folds while validating on the remaining fold, and rotating through all combinations. This provides a more robust model performance assessment than a single train-test split, helping detect overfitting and estimate model generalization to unseen data. Variations include stratified k-fold (maintaining class distribution), leave-one-out (k equals dataset size), and time series cross-validation for temporal data."}], "output": "Cross-validation evaluates ML models by training and testing on different data splits, typically using k-fold methodology. This approach offers better performance assessment than single splits, with variations for different data types and requirements."}      
+    {"input": [{"role": "system", "content": "Generate a clear and focused summary that captures the essential technical details while maintaining their relationships and significance."}, {"role": "user", "content": "Transfer learning is a machine learning method where a model developed for one task is reused as the starting point for a model on a second task. This approach is powerful in deep learning, where pre-trained models on large datasets (like ImageNet for computer vision or BERT for NLP) are fine-tuned on specific downstream tasks. Transfer learning reduces the need for large amounts of task-specific training data and computational resources, as the model has already learned useful features from the source domain. Common strategies include feature extraction (freezing pre-trained layers) and fine-tuning (updating all or some pre-trained weights)."}], "output": "Transfer learning reuses models trained on one task for different tasks, particularly effective in deep learning. It leverages pre-trained models through feature extraction or fine-tuning, reducing data and computational needs for new tasks."}      
+    {"input": [{"role": "system", "content": "Provide a precise and informative summary that distills the key technical concepts while maintaining their relationships and practical importance."}, {"role": "user", "content": "Ensemble methods combine multiple machine learning models to create a more robust and accurate predictor. Common techniques include bagging (training models on random data subsets), boosting (sequentially training models to correct earlier errors), and stacking (using a meta-model to combine base model predictions). Random Forests, a popular bagging method, create multiple decision trees using random feature subsets. Gradient Boosting builds trees sequentially, with each tree correcting the errors of previous ones. These methods often outperform single models by reducing overfitting and variance while capturing different data aspects."}], "output": "Ensemble methods enhance prediction accuracy by combining multiple models through techniques like bagging, boosting, and stacking. Popular implementations include Random Forests (using multiple trees with random features) and Gradient Boosting (sequential error correction), offering better performance than single models."}
+    ```
+
+    You'll see the first three lines of the file as a preview:
+
+    :::image type="content" source="../media/how-to/evaluations/preview.png" alt-text="Screenshot that shows a preview of an uploaded evaluation file." lightbox="../media/how-to/evaluations/preview.png":::
+
+5. Select the toggle for **Generate responses**. Select `{{item.input}}` from the dropdown. This will inject the input fields from our evaluation file into individual prompts for a new model run that we want to able to compare against our evaluation dataset. The model will take that input and generate its own unique outputs which in this case will be stored in a variable called `{{sample.output_text}}`. We'll then use that sample output text later as part of our testing criteria. Alternatively you could provide your own custom system message and individual message examples manually.
+
+6. Select which model you want to generate responses based on your evaluation. If you don't have a model you can create one. For the purpose of this example we're using a standard deployment of `gpt-4o-mini`.
+
+    :::image type="content" source="../media/how-to/evaluations/item-input.png" alt-text="Screenshot of the UX for generating model responses with a model selected." lightbox="../media/how-to/evaluations/item-input.png":::
+
+    The settings/sprocket symbol controls the basic parameters that are passed to the model. Only the following parameters are supported at this time:
+
+- **Temperature**
+- **Maximum length**
+- **Top P**
+
+ Maximum length is currently capped at 2048 regardless of what model you select.
+
+7. Select **Add testing criteria** select **Add**.
+
+8. Select **Semantic Similarity** >  Under **Compare** add `{{item.output}}` under **With** add ``{{sample.output_text}}``. This will take the original reference output from your evaluation `.jsonl` file and compare it against the output that will be generated by giving the model prompts based on your ``{{item.input}}``.
+
+    :::image type="content" source="../media/how-to/evaluations/semantic-similarity-config.png" alt-text="Screenshot of the semantic similarity UX config." lightbox="../media/how-to/evaluations/semantic-similarity-config.png":::
+
+9. Select **Add** > at this point you can either add additional testing criteria or you select Create to initiate the evaluation job run.
+
+10. Once you select **Create** you'll be taken to a status page for your evaluation job.
+
+    :::image type="content" source="../media/how-to/evaluations/status.png" alt-text="Screenshot of the evaluation status UX." lightbox="../media/how-to/evaluations/status.png":::
+
+11. Once your evaluation job has created you can select the job to view the full details of the job:
+
+    :::image type="content" source="../media/how-to/evaluations/test-complete.png" alt-text="Screenshot of a completed semantic similarity test with mix of pass and failures." lightbox="../media/how-to/evaluations/test-complete.png":::
+
+12. For semantic similarity **View output details** contains a JSON representation that you can copy/paste of your passing tests.
+
+    :::image type="content" source="../media/how-to/evaluations/output-details.png" alt-text="Screenshot of the evaluation status UX with output details." lightbox="../media/how-to/evaluations/output-details.png":::
+
+## Testing criteria details
+
+Azure OpenAI Evaluation offers multiple testing criteria options. The section below provides additional details on each option.
+
+### Factuality
+
+Assesses the factual accuracy of a submitted answer by comparing it against an expert answer.
+
+Factuality evaluates the factual accuracy of a submitted answer by comparing it to an expert answer. Utilizing a detailed chain-of-thought (CoT) prompt, the grader determines whether the submitted answer is consistent with, a subset of, a superset of, or in conflict with the expert answer. It disregards differences in style, grammar, or punctuation, focusing solely on factual content. Factuality can be useful in many scenarios including but not limited to content verification and educational tools ensuring the accuracy of answers provided by AI.
+
+:::image type="content" source="../media/how-to/evaluations/factuality.png" alt-text="Screenshot of the factuality testing criteria." lightbox="../media/how-to/evaluations/factuality.png":::
+
+You can view the prompt text that is used as part of this testing criteria by selecting the dropdown next to the prompt. The current prompt text is:
+
+```text
+Prompt
+You are comparing a submitted answer to an expert answer on a given question.
+Here is the data:
+[BEGIN DATA]
+************
+[Question]: {input}
+************
+[Expert]: {ideal}
+************
+[Submission]: {completion}
+************
+[END DATA]
+Compare the factual content of the submitted answer with the expert answer. Ignore any differences in style, grammar, or punctuation.
+The submitted answer may either be a subset or superset of the expert answer, or it may conflict with it. Determine which case applies. Answer the question by selecting one of the following options:
+(A) The submitted answer is a subset of the expert answer and is fully consistent with it.
+(B) The submitted answer is a superset of the expert answer and is fully consistent with it.
+(C) The submitted answer contains all the same details as the expert answer.
+(D) There is a disagreement between the submitted answer and the expert answer.
+(E) The answers differ, but these differences don't matter from the perspective of factuality.
+```
+
+### Semantic similarity
+
+Measures the degree of similarity between model's response and the reference. `Grades: 1 (completely different) - 5 (very similar)`.
+
+:::image type="content" source="../media/how-to/evaluations/semantic-similarity.png" alt-text="Screenshot of the semantic similarity testing criteria." lightbox="../media/how-to/evaluations/semantic-similarity.png":::
+
+### Sentiment
+
+Attempts to identify the emotional tone of the output.
+
+:::image type="content" source="../media/how-to/evaluations/sentiment.png" alt-text="Screenshot of the sentiment testing criteria." lightbox="../media/how-to/evaluations/sentiment.png":::
+
+You can view the prompt text that is used as part of this testing criteria by selecting the dropdown next to the prompt. The current prompt text is:
+
+```text
+Prompt
+You will be presented with a text generated by a large language model. Your job is to rate the sentiment of the text. Your options are:
+
+A) Positive
+B) Neutral
+C) Negative
+D) Unsure
+
+[BEGIN TEXT]
+***
+[{text}]
+***
+[END TEXT]
+
+First, write out in a step by step manner your reasoning about the answer to be sure that your conclusion is correct. Avoid simply stating the correct answers at the outset. Then print only the single character (without quotes or punctuation) on its own line corresponding to the correct answer. At the end, repeat just the letter again by itself on a new line
+```
+
+### String check
+
+Verifies if the output matches the expected string exactly.
+
+:::image type="content" source="../media/how-to/evaluations/string-check.png" alt-text="Screenshot of the string check testing criteria." lightbox="../media/how-to/evaluations/string-check.png":::
+
+String check performs various binary operations on two string variables allowing for diverse evaluation criteria. It helps with verifying various string relationships, including equality, containment, and specific patterns. This evaluator allows for case-sensitive or case-insensitive comparisons. It also provides specified grades for true or false results, allowing customized evaluation outcomes based on the comparison result. Here's the type of operations supported:
+- `equals`: Checks if the output string is exactly equal to the evaluation string.
+- `contains`: Checks if the evaluation string is a substring of output string.
+- `starts-with`: Checks if the output string starts with the evaluation string.
+- `ends-with`: Checks if the output string ends with the evaluation string.
+
+> [!NOTE]
+> When setting certain parameters in your testing criteria, you have the option to choose between the *variable* and the *template*. Select *variable* if you want to refer to a column in your input data. Choose *template* if you want to provide a fixed string.
+
+### Valid JSON or XML
+
+Verifies if the output is valid JSON or XML.
+
+:::image type="content" source="../media/how-to/evaluations/valid-json.png" alt-text="Screenshot of the valid json or XML testing criteria." lightbox="../media/how-to/evaluations/valid-json.png":::
+
+### Matches schema
+
+Ensures the output follows the specified structure.
+
+:::image type="content" source="../media/how-to/evaluations/matches-schema.png" alt-text="Screenshot of the matches schema testing criteria." lightbox="../media/how-to/evaluations/matches-schema.png":::
+
+### Criteria match
+
+Assess if model's response matches your criteria. Grade: Pass or Fail.
+
+:::image type="content" source="../media/how-to/evaluations/criteria-match.png" alt-text="Screenshot of the matches criteria test." lightbox="../media/how-to/evaluations/criteria-match.png":::
+
+You can view the prompt text that is used as part of this testing criteria by selecting the dropdown next to the prompt. The current prompt text is:
+
+```text
+Prompt
+Your job is to assess the final response of an assistant based on conversation history and provided criteria for what makes a good response from the assistant. Here is the data:
+
+[BEGIN DATA]
+***
+[Conversation]: {conversation}
+***
+[Response]: {response}
+***
+[Criteria]: {criteria}
+***
+[END DATA]
+
+Does the response meet the criteria? First, write out in a step by step manner your reasoning about the criteria to be sure that your conclusion is correct. Avoid simply stating the correct answers at the outset. Then print only the single character "Y" or "N" (without quotes or punctuation) on its own line corresponding to the correct answer. "Y" for yes if the response meets the criteria, and "N" for no if it does not. At the end, repeat just the letter again by itself on a new line.
+Reasoning:
+```
+
+### Text quality
+
+Evaluate quality of text by comparing to reference text.
+
+:::image type="content" source="../media/how-to/evaluations/text-quality-general.png" alt-text="Screenshot of the text quality testing criteria." lightbox="../media/how-to/evaluations/text-quality-general.png":::
+
+**Summary:**
+
+- BLEU Score: Evaluates the quality of generated text by comparing it against one or more high-quality reference translations using the BLEU score.
+- ROUGE Score: Evaluates the quality of generated text by comparing it to reference summaries using ROUGE scores.
+- Cosine: Also referred to as cosine similarity measures how closely two text embeddings—such as model outputs and reference texts—align in meaning, helping assess the semantic similarity between them. This is done by measuring their distance in vector space.
+
+**Details:**
+
+BLEU (BiLingual Evaluation Understudy) score is commonly used in natural language processing (NLP) and machine translation. It's widely used in text summarization and text generation use cases. It evaluates how closely the generated text matches the reference text. The BLEU score ranges from 0 to 1, with higher scores indicating better quality.
+
+ROUGE (Recall-Oriented Understudy for Gisting Evaluation) is a set of metrics used to evaluate automatic summarization and machine translation. It measures the overlap between generated text and reference summaries. ROUGE focuses on recall-oriented measures to assess how well the generated text covers the reference text.
+The ROUGE score provides various metrics, including:
+•	ROUGE-1: Overlap of unigrams (single words) between generated and reference text.
+•	ROUGE-2: Overlap of bigrams (two consecutive words) between generated and reference text.
+•	ROUGE-3: Overlap of trigrams (three consecutive words) between generated and reference text.
+•	ROUGE-4: Overlap of four-grams (four consecutive words) between generated and reference text.
+•	ROUGE-5: Overlap of five-grams (five consecutive words) between generated and reference text.
+•	ROUGE-L: Overlap of L-grams (L consecutive words) between generated and reference text.
+Text summarization and document comparison are among optimal use cases for ROUGE, particularly in scenarios where text coherence and relevance are critical.
+
+Cosine similarity measures how closely two text embeddings—such as model outputs and reference texts—align in meaning, helping assess the semantic similarity between them. Same as other model-based evaluators, you need to provide a model deployment using for evaluation. 
+
+> [!IMPORTANT]
+> Only embedding models are supported for this evaluator:
+>
+> -	`text-embedding-3-small`
+> -	`text-embedding-3-large`
+> -	`text-embedding-ada-002`
+
+### Custom prompt
+
+Uses the model to classify the output into a set of specified labels. This evaluator uses a custom prompt that you'll need to define.
+
+:::image type="content" source="../media/how-to/evaluations/custom-prompt.png" alt-text="Screenshot of the custom prompt testing criteria." lightbox="../media/how-to/evaluations/custom-prompt.png":::

@@ -24,7 +24,7 @@ Azure OpenAI Service lets you tailor our models to your personal datasets by usi
 
 In contrast to few-shot learning, fine tuning improves the model by training on many more examples than can fit in a prompt, letting you achieve better results on a wide number of tasks. Because fine tuning adjusts the base model’s weights to improve performance on the specific task, you won’t have to include as many examples or instructions in your prompt. This means less text sent and fewer tokens processed on every API call, potentially saving cost, and improving request latency.
 
-We use LoRA, or low rank approximation, to fine-tune models in a way that reduces their complexity without significantly affecting their performance. This method works by approximating the original high-rank matrix with a lower rank one, thus only fine-tuning a smaller subset of "important" parameters during the supervised training phase, making the model more manageable and efficient. For users, this makes training faster and more affordable than other techniques.
+We use LoRA, or low rank approximation, to fine-tune models in a way that reduces their complexity without significantly affecting their performance. This method works by approximating the original high-rank matrix with a lower rank one, thus only fine-tuning a smaller subset of *important* parameters during the supervised training phase, making the model more manageable and efficient. For users, this makes training faster and more affordable than other techniques.
 
 > [!NOTE]
 > Azure OpenAI currently only supports text-to-text fine-tuning for all supported models including GPT-4o mini.
@@ -47,9 +47,44 @@ We use LoRA, or low rank approximation, to fine-tune models in a way that reduce
 
 ::: zone-end
 
+## Vision fine-tuning
+
+Fine-tuning is also possible with images in your JSONL files. Just as you can send one or many image inputs to chat completions, you can include those same message types within your training data. Images can be provided either as publicly accessible URLs or data URIs containing [base64 encoded images](/azure/ai-services/openai/how-to/gpt-with-vision?tabs=rest#call-the-chat-completion-apis). 
+
+### Image dataset requirements
+
+- Your training file can contain a maximum of 50,000 examples that contain images (not including text examples).
+- Each example can have at most 64 images.
+- Each image can be at most 10 MB.
+
+### Format
+
+Images must be:
+
+- JPEG
+- PNG
+- WEBP
+
+Images must be in the RGB or RGBA image mode.
+
+You cannot include images as output from messages with the assistant role.
+
+### Content moderation policy
+
+We scan your images before training to ensure that they comply with our usage policy [Transparency Note](/legal/cognitive-services/openai/transparency-note?context=%2Fazure%2Fai-services%2Fopenai%2Fcontext%2Fcontext&tabs=text). This may introduce latency in file validation before fine tuning begins.
+
+Images containing the following will be excluded from your dataset and not used for training:
+
+- People
+- Faces
+- CAPTCHAs
+
+> [!IMPORTANT]
+>For  vision fine tuning face screening process: We screen for faces/people to skip those images from training the model. The screening capability leverages face detection **WITHOUT** Face identification which means we don't create facial templates or measure specific facial geometry, and the technology used to screen for faces is incapable of uniquely identifying the individuals. To know more about data and Privacy for face refer to - [Data and privacy for Face - Azure AI services | Microsoft Learn](/legal/cognitive-services/computer-vision/imageanalysis-data-privacy-security?context=%2Fazure%2Fai-services%2Fcomputer-vision%2Fcontext%2Fcontext).
+
 ## Troubleshooting
 
-### How do I enable fine-tuning? Create a custom model is greyed out in Azure OpenAI Studio?
+### How do I enable fine-tuning?
 
 In order to successfully access fine-tuning, you need **Cognitive Services OpenAI Contributor assigned**. Even someone with high-level Service Administrator permissions would still need this account explicitly set in order to access fine-tuning. For more information, please review the [role-based access control guidance](/azure/ai-services/openai/how-to/role-based-access-control#cognitive-services-openai-contributor).
 
@@ -67,6 +102,55 @@ If your file upload fails in Azure OpenAI Studio, you can view the error message
 
 - **Bad data:** A poorly curated or unrepresentative dataset will produce a low-quality model. Your model may learn inaccurate or biased patterns from your dataset. For example, if you are training a chatbot for customer service, but only provide training data for one scenario (e.g. item returns) it will not know how to respond to other scenarios. Or, if your training data is bad (contains incorrect responses), your model will learn to provide incorrect results.
 
+### Fine-tuning with vision
+
+**What to do if your images get skipped**
+
+Your images can get skipped for the following reasons:
+
+- contains CAPTCHAs
+- contains people
+- contains faces
+
+Remove the image. For now, we cannot fine-tune models with images containing these entities.
+
+**Common issues**
+
+|Issue| Reason/Solution|
+|:----|:-----|
+|**Images skipped**| Images can get skipped for the following reasons: contains CAPTCHAs, people, or faces.<br><br> Remove the image. For now, we cannot fine-tune models with images containing these entities.|
+|**Inaccessible URL**| Check that the image URL is publicly accessible.|
+|**Image too large**| Check that your images fall within our dataset size limits.|
+|**Invalid image format**| Check that your images fall within our dataset format.|
+
+**How to upload large files**
+
+Your training files might get quite large. You can upload files up to 8 GB in multiple parts using the [Uploads API](/rest/api/azureopenai/upload-file?view=rest-azureopenai-2024-10-21&preserve-view=true) as opposed to the Files API, which only allows file uploads of up to 512 MB.
+
+**Reducing training cost**
+
+If you set the detail parameter for an image to low, the image is resized to 512 by 512 pixels and is only represented by 85 tokens regardless of its size. This will reduce the cost of training.
+
+```json
+{ 
+
+    "type": "image_url", 
+
+    "image_url": { 
+
+        "url": "https://raw.githubusercontent.com/MicrosoftDocs/azure-ai-docs/main/articles/ai-services/openai/media/how-to/generated-seattle.png", 
+
+        "detail": "low" 
+
+    } 
+
+} 
+```
+
+**Other considerations for vision fine-tuning**
+
+To control the fidelity of image understanding, set the detail parameter of `image_url` to `low`, `high`, or `auto` for each image. This will also affect the number of tokens per image that the model sees during training time and will affect the cost of training.
+
 ## Next steps
 
 - Explore the fine-tuning capabilities in the [Azure OpenAI fine-tuning tutorial](../tutorials/fine-tune.md).

@@ -18,7 +18,7 @@ You can also review forecasted costs and identify spending trends to identify ar
 
 ## Prerequisites
 
-Cost analysis in Cost Management supports most Azure account types, but not all of them. To view the full list of supported account types, see [Understand Cost Management data](/azure/cost-management-billing/costs/understand-cost-mgt-data?WT.mc_id=costmanagementcontent_docsacmhorizontal_-inproduct-learn). To view cost data, you need at least read access for an Azure account. For information about assigning access to Azure Cost Management data, see [Assign access to data](/azure/cost-management/assign-access-acm-data?WT.mc_id=costmanagementcontent_docsacmhorizontal_-inproduct-learn).
+Cost analysis in Cost Management supports most Azure account types, but not all of them. To view the full list of supported account types, see [Understand Cost Management data](/azure/cost-management-billing/costs/understand-cost-mgt-data?WT.mc_id=costmanagementcontent_docsacmhorizontal_-inproduct-learn). To view cost data, you need at least read access for an Azure account. For information about assigning access to Microsoft Cost Management data, see [Assign access to data](/azure/cost-management/assign-access-acm-data?WT.mc_id=costmanagementcontent_docsacmhorizontal_-inproduct-learn).
 
 ## Estimate costs before using Azure OpenAI
 
@@ -28,25 +28,26 @@ Use the [Azure pricing calculator](https://azure.microsoft.com/pricing/calculato
 
 Azure OpenAI Service runs on Azure infrastructure that accrues costs when you deploy new resources. There could be other infrastructure costs that might accrue. The following sections describe how you're charged for Azure OpenAI Service.
 
-### Base series and Codex series models
+### Model inference chat completions
 
-Azure OpenAI base series and Codex series models are charged per 1,000 tokens. Costs vary depending on which model series you choose: Ada, Babbage, Curie, Davinci, or Code-Cushman.
+Azure OpenAI chat completions model inference is [charged per 1,000 tokens with different rates](https://azure.microsoft.com/pricing/details/cognitive-services/openai-service/) depending on model and [deployment type](./deployment-types.md).
 
 Azure OpenAI models understand and process text by breaking it down into tokens. For reference, each token is roughly four characters for typical English text.
 
 Token costs are for both input and output. For example, suppose you have a 1,000 token JavaScript code sample that you ask an Azure OpenAI model to convert to Python. You would be charged approximately 1,000 tokens for the initial input request sent, and 1,000 more tokens for the output that is received in response for a total of 2,000 tokens.
 
 In practice, for this type of completion call, the token input/output wouldn't be perfectly 1:1. A conversion from one programming language to another could result in a longer or shorter output depending on many factors. One such factor is the value assigned to the `max_tokens` parameter.
 
-### Base Series and Codex series fine-tuned models
+### Fine-tuned models
 
-Azure OpenAI fine-tuned models are charged based on three factors:
+Azure OpenAI fine-tuning models are charged based on the [number of tokens in your training file](https://techcommunity.microsoft.com/blog/azure-ai-services-blog/pricing-update-token-based-billing-for-fine-tuning-training-%F0%9F%8E%89/4164465). For the latest prices, see the [official pricing page](https://azure.microsoft.com/pricing/details/cognitive-services/openai-service/).
+
+Once your fine-tuned model is deployed, you're also charged based on:
 
-- Training hours
 - Hosting hours
-- Inference per 1,000 tokens
+- Inference per 1,000 tokens (broken down by input usage and output usage)
 
-The hosting hours cost is important to be aware of since after a fine-tuned model is deployed, it continues to incur an hourly cost regardless of whether you're actively using it. Monitor fine-tuned model costs closely.
+The hosting hours cost is important to be aware of since after a fine-tuned model is deployed, it continues to incur an hourly cost regardless of whether you're actively using it. Monitor deployed fine-tuned model costs closely.
 
 > [!IMPORTANT]
 > After you deploy a customized model, if at any time the deployment remains inactive for greater than fifteen (15) days,
@@ -130,7 +131,7 @@ You can also [export your cost data](/azure/cost-management-billing/costs/tutori
 
 ## Next steps
 
-- Learn [how to optimize your cloud investment with Azure Cost Management](/azure/cost-management-billing/costs/cost-mgt-best-practices?WT.mc_id=costmanagementcontent_docsacmhorizontal_-inproduct-learn).
+- Learn [how to optimize your cloud investment with Microsoft Cost Management](/azure/cost-management-billing/costs/cost-mgt-best-practices?WT.mc_id=costmanagementcontent_docsacmhorizontal_-inproduct-learn).
 - Learn more about managing costs with [cost analysis](/azure/cost-management-billing/costs/quick-acm-cost-analysis?WT.mc_id=costmanagementcontent_docsacmhorizontal_-inproduct-learn).
 - Learn about how to [prevent unexpected costs](/azure/cost-management-billing/understand/analyze-unexpected-charges?WT.mc_id=costmanagementcontent_docsacmhorizontal_-inproduct-learn).
 - Take the [Cost Management](/training/paths/control-spending-manage-bills?WT.mc_id=costmanagementcontent_docsacmhorizontal_-inproduct-learn) guided learning course.

@@ -0,0 +1,99 @@
+---
+title: 'Integrate Azure OpenAI with Weights & Biases'
+titleSuffix: Azure OpenAI
+description: Learn how to integrate Weights & Biases and Azure OpenAI fine-tuning.
+manager: nitinme
+ms.service: azure-ai-openai
+ms.custom: 
+ms.topic: how-to
+ms.date: 11/10/2024
+author: mrbullwinkle
+ms.author: mbullwin
+---
+
+# Integrate Azure OpenAI fine-tuning with Weights & Biases (preview)
+
+Weights & Biases (W&B) is a powerful AI developer platform that enables machine learning practitioners to train, fine-tune, and deploy models efficiently. Azure OpenAI fine-tuning integrates with W&B, allowing you to track metrics, parameters, and visualize your Azure OpenAI fine-tuning training runs within your W&B projects. In this article, we will guide you through setting up the Weights & Biases integration.
+
+:::image type="content" source="../media/how-to/weights-and-biases/dashboards.png" alt-text="Screenshot of the weights and biases dashboards." lightbox="../media/how-to/weights-and-biases/dashboards.png":::
+
+## Prerequisites
+
+- An Azure OpenAI resource. For more information, see [Create a resource and deploy a model with Azure OpenAI](../how-to/create-resource.md). The resource should be in a [region that supports fine-tuning](../concepts/models.md#fine-tuning-models).
+- All users on your team who need to fine-tune models should have **Cognitive Services OpenAI Contributor** access assigned for the new Azure OpenAI resource.
+- A [Weights & Biases](https://wandb.ai) account and API key.
+- [Azure Key Vault](https://portal.azure.com/#create/Microsoft.KeyVault). For more information on creating a key vault, see the [Azure Key Vault quickstart](/azure/key-vault/general/quick-create-portal).
+
+## Enable System Managed Identity
+
+First you will need to enable [System Managed Identity](/entra/identity/managed-identities-azure-resources/overview) for your Azure OpenAI resource.
+
+:::image type="content" source="../media/how-to/weights-and-biases/system-managed.png" alt-text="Screenshot of the system managed identity enabled user experience." lightbox="../media/how-to/weights-and-biases/system-managed.png":::
+
+## Retrieve Weights & Biases API key
+
+Sign in to [https://wandb.ai](https://wandb.ai) and go to [User Settings](https://wandb.ai/settings).
+
+Under **API Keys** select **Reveal** to access your key and copy to the clipboard.
+
+:::image type="content" source="../media/how-to/weights-and-biases/reveal-key.png" alt-text="Screenshot of API keys section of User Settings user experience." lightbox="../media/how-to/weights-and-biases/reveal-key.png":::
+
+If you would like to create a new key use [https://wandb.ai/authorize](https://wandb.ai/authorize), and copy the key to add to your integration configuration later.
+
+## Configure Azure Key Vault
+
+In order to securely, send data from Azure OpenAI to your Weights & Biases projects you'll need to use [Azure Key Vault](/azure/key-vault/general/overview).
+
+### Add your Weights & Biases API key as a Secret to your Azure Key Vault
+
+1. Navigate to the Azure Key Vault you are planning to use.
+2. To read\write secrets to your Azure Key Vault, you must explicitly assign access.
+3. Go to Settings > Access configuration, under Permission model we recommend you select Azure role-based access control if this isn't already selected. Learn more about [Azure role-based access control](/azure/role-based-access-control/overview?WT.mc_id=Portal-Microsoft_Azure_KeyVault).
+
+    :::image type="content" source="../media/how-to/weights-and-biases/role-based-access-control.png" alt-text="Screenshot of key vault access configuration user interface." lightbox="../media/how-to/weights-and-biases/role-based-access-control.png":::
+
+### Assign Key Vault Secrets Officer role
+
+Now that you set your permission model to Azure role-based access control, you can give yourself the **Key Vault Secrets Officer** role.
+
+1. Go to **Access control (IAM)** and then **Add role assignment**
+
+    :::image type="content" source="../media/how-to/weights-and-biases/access-control.png" alt-text="Screenshot of the access control add role assignment user experience." lightbox="../media/how-to/weights-and-biases/access-control.png":::
+
+2. Choose **Key Vault Secrets Officer** and add your account as a member and select **review & assign**.
+
+    :::image type="content" source="../media/how-to/weights-and-biases/key-vault-secret-officer.png" alt-text="Screenshot of the key vault secret officer role assignment." lightbox="../media/how-to/weights-and-biases/key-vault-secret-officer.png":::
+
+### Create secrets
+
+1. From within your key vault resource under **Objects** and select **Secrets** > **Generate/Import**.
+
+    :::image type="content" source="../media/how-to/weights-and-biases/secrets.png" alt-text="Screenshot of the key vault secrets user interface." lightbox="../media/how-to/weights-and-biases/secrets.png":::
+
+2. Provide a name to your secret and save the generated API key from Weights & Biases to the **secret value**.
+
+    :::image type="content" source="../media/how-to/weights-and-biases/create-secret.png" alt-text="Screenshot of the key vault secrets creation user interface." lightbox="../media/how-to/weights-and-biases/create-secret.png":::
+
+3. Make sure to capture the secret name and key vault url. Key vault URL can be retrieved from **Overview** section of your key-vault.
+
+### Give your Key Vault permission on your Azure OpenAI account
+
+If you used vault access policy earlier to read/write secrets to your Azure Key Vault, you should use that again. Otherwise, continue to use Azure role-based access control. **We recommend Azure role-based access control, though if it does not work for you, please try Vault Access policy.**
+
+Give your Azure OpenAI resource the **Key Vault Secrets Officer** role.
+
+:::image type="content" source="../media/how-to/weights-and-biases/assign.png" alt-text="Screenshot of the assign managed identity user interface." lightbox="../media/how-to/weights-and-biases/assign.png":::
+
+## Link Weights & Biases with Azure OpenAI
+
+1. Navigate to [AI Studio](https://ai.azure.com) and select your Azure OpenAI fine-tuning resource.
+
+    :::image type="content" source="../media/how-to/weights-and-biases/manage-integrations.png" alt-text="Screenshot of the manage integrations button." lightbox="../media/how-to/weights-and-biases/manage-integrations.png":::
+
+2. Add your key vault URL and secret > then select **Update**.
+
+    :::image type="content" source="../media/how-to/weights-and-biases/integration.png" alt-text="Screenshot of the manage integrations for Weights and Biases user experience." lightbox="../media/how-to/weights-and-biases/integration.png":::
+
+3. Now when you create new fine-tuning jobs you'll have the option to log data from the job to your Weights & Biases account.
+
+    :::image type="content" source="../media/how-to/weights-and-biases/dashboards.png" alt-text="Screenshot of the weights and biases dashboards." lightbox="../media/how-to/weights-and-biases/dashboards.png":::
\ No newline at end of file

@@ -4638,7 +4638,7 @@ Represents a completion response from the API. Note: both the streamed and non-s
 |------|------|-------------|----------|---------|
 | description | string | A description of what the function does, used by the model to choose when and how to call the function. | No |  |
 | name | string | The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64. | Yes |  |
-| parameters | [FunctionParameters](#functionparameters) | The parameters the functions accepts, described as a JSON Schema object. See the guide](/azure/ai-services/openai/how-to/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format. <br><br>Omitting `parameters` defines a function with an empty parameter list. | No |  |
+| parameters | [FunctionParameters](#functionparameters) | The parameters the functions accepts, described as a JSON Schema object. [See the guide](/azure/ai-services/openai/how-to/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format. <br><br>Omitting `parameters` defines a function with an empty parameter list. | No |  |
 
 
 ### chatCompletionFunctionCallOption
@@ -5296,7 +5296,7 @@ on an Azure OpenAI endpoint call for embeddings.
 | Name | Type | Description | Required | Default |
 |------|------|-------------|----------|---------|
 | type | [onYourDataVectorizationSourceType](#onyourdatavectorizationsourcetype) | Represents the available sources Azure OpenAI On Your Data can use to configure vectorization of data for use with<br>vector search. | Yes |  |
-| endpoint | string | Specifies the resource endpoint URL from which embeddings should be retrieved. It should be in the format of https://YOUR_RESOURCE_NAME.openai.azure.com/openai/deployments/YOUR_DEPLOYMENT_NAME/embeddings. The api-version query parameter isn't allowed. | No |  |
+| endpoint | string | Specifies the resource endpoint URL from which embeddings should be retrieved. It should be in the format of `https://YOUR_RESOURCE_NAME.openai.azure.com/openai/deployments/YOUR_DEPLOYMENT_NAME/embeddings`. The api-version query parameter isn't allowed. | No |  |
 | authentication | [onYourDataApiKeyAuthenticationOptions](#onyourdataapikeyauthenticationoptions) or [onYourDataAccessTokenAuthenticationOptions](#onyourdataaccesstokenauthenticationoptions) |  | No |  |
 | dimensions | integer | The number of dimensions the embeddings should have. Only supported in `text-embedding-3` and later models. | No |  |
 

@@ -1263,7 +1263,7 @@ Represents a completion response from the API. Note: both the streamed and nonst
 |------|------|-------------|----------|---------|
 | description | string | A description of what the function does, used by the model to choose when and how to call the function. | No |  |
 | name | string | The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64. | Yes |  |
-| parameters | [FunctionParameters](#functionparameters) | The parameters the functions accepts, described as a JSON Schema object. See the guide](/azure/ai-services/openai/how-to/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format. <br><br>Omitting `parameters` defines a function with an empty parameter list. | No |  |
+| parameters | [FunctionParameters](#functionparameters) | The parameters the functions accepts, described as a JSON Schema object. [See the guide](/azure/ai-services/openai/how-to/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format. <br><br>Omitting `parameters` defines a function with an empty parameter list. | No |  |
 
 
 ### chatCompletionFunctionCallOption
@@ -2017,7 +2017,7 @@ Usage statistics for the completion request.
 
 ### FunctionParameters
 
-The parameters the functions accepts, described as a JSON Schema object. See the guide](/azure/ai-services/openai/how-to/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format. 
+The parameters the functions accepts, described as a JSON Schema object. [See the guide](/azure/ai-services/openai/how-to/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format. 
 
 Omitting `parameters` defines a function with an empty parameter list.
 
@@ -2032,7 +2032,7 @@ No properties defined for this component.
 |------|------|-------------|----------|---------|
 | description | string | A description of what the function does, used by the model to choose when and how to call the function. | No |  |
 | name | string | The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64. | Yes |  |
-| parameters | [FunctionParameters](#functionparameters) | The parameters the functions accepts, described as a JSON Schema object. See the guide](/azure/ai-services/openai/how-to/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format. <br><br>Omitting `parameters` defines a function with an empty parameter list. | No |  |
+| parameters | [FunctionParameters](#functionparameters) | The parameters the functions accepts, described as a JSON Schema object. [See the guide](/azure/ai-services/openai/how-to/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format. <br><br>Omitting `parameters` defines a function with an empty parameter list. | No |  |
 | strict | boolean | Whether to enable strict schema adherence when generating the function call. If set to true, the model will follow the exact schema defined in the `parameters` field. Only a subset of JSON Schema is supported when `strict` is `true`. | No | False |
 
 

@@ -26,11 +26,11 @@ author: mrbullwinkle
 
 1. Sign in to [Azure AI Studio](https://ai.azure.com).
 1. Go to your project or [create a new project](../../../ai-studio//how-to/create-projects.md) in Azure AI Studio.
-1. From your project overview, select **Assistants**, located under **Project playground**.
+1. From your project overview, select **Assistants**, located under **playgrounds**.
 
     The Assistants playground allows you to explore, prototype, and test AI Assistants without needing to run any code. From this page, you can quickly iterate and experiment with new ideas.
     
-    The playground provides several options to configure your Assistant. In the following steps, you will use the **Assistant setup** pane to create a new AI assistant.
+    The playground provides several options to configure your Assistant. In the following steps, you will use the **setup** pane to create a new AI assistant.
     
     | **Name** | **Description** |
     |:---|:---|
@@ -46,7 +46,7 @@ author: mrbullwinkle
 ## Create your first Assistant
 
 1. Select your deployment from the **Deployments** dropdown.
-1. From the Assistant setup drop-down, select **New**.
+1. From the Assistant setup drop-down, select **New assistant**.
 1. Give your Assistant a name.
 1. Enter the following instructions "You are an AI assistant that can write code to help answer math questions"
 1. Select a model deployment. We recommend testing with one of the latest gpt-4 models.

@@ -6,7 +6,7 @@ ms.service: azure-ai-openai
 ms.topic: include
 author: aahill
 ms.author: aahi
-ms.date: 02/15/2024
+ms.date: 11/06/2024
 recommendations: false
 ---
 
@@ -15,15 +15,17 @@ recommendations: false
 > [!TIP]
 > You can [use the Azure Developer CLI](../how-to/azure-developer-cli.md) to programmatically create the resources needed for Azure OpenAI On Your Data 
 
-Navigate to [Azure OpenAI Studio](https://oai.azure.com/) and sign-in with credentials that have access to your Azure OpenAI resource. During or after the sign-in workflow, select the appropriate directory, Azure subscription, and Azure OpenAI resource.
+Navigate to [Azure AI Studio](https://ai.azure.com/) and sign-in with credentials that have access to your Azure OpenAI resource. 
 
-1. Select the **Bring your own data** tile
+1. You can either [create an AI studio project](../../../ai-studio/how-to/create-projects.md) by clicking **Create project**, or continue directly by clicking the button on the **Focused on Azure OpenAI Service** tile.  
 
-    :::image type="content" source="../media/use-your-data/bring-your-data-card-new.png" alt-text="A screenshot of the Azure OpenAI Studio landing page." lightbox="../media/use-your-data/bring-your-data-card-new.png":::
+    :::image type="content" source="../media/use-your-data/ai-studio-homepage.png" alt-text="A screenshot of the Azure AI Studio landing page." lightbox="../media/use-your-data/ai-studio-homepage.png":::
+
+1. Select **Chat** under **Playgrounds** in the left navigation menu, and select your model deployment.
 
 1. In the **Chat playground**, Select **Add your data** and then **Add a data source**
 
-    :::image type="content" source="../media/use-your-data/chat-playground.png" alt-text="A screenshot of the chat playground in  OpenAI Studio." lightbox="../media/use-your-data/chat-playground.png":::
+    :::image type="content" source="../media/use-your-data/chat-playground.png" alt-text="A screenshot of the chat playground in  AI Studio." lightbox="../media/use-your-data/chat-playground.png":::
 
 1. In the pane that appears, select **Upload files (preview)** under **Select data source**. Azure OpenAI needs both a storage resource and a search resource to access and index your data. 
 

@@ -23,7 +23,7 @@ manager: nitinme
 | `gpt-35-turbo` (1106) | East US2 <br> North Central US <br> Sweden Central <br> Switzerland West | Input: 16,385<br> Output: 4,096 |  Sep 2021|
 | `gpt-35-turbo` (0125)  | East US2 <br> North Central US <br> Sweden Central <br> Switzerland West | 16,385 | Sep 2021 |
 | `gpt-4` (0613) <sup>**1**</sup> | North Central US <br> Sweden Central | 8192 | Sep 2021 |
-| `gpt-4o-mini` <sup>**1**</sup> (2024-07-18) | North Central US <br> Sweden Central | Input: 128,000 <br> Output: 16,384  <br> Training example context length: 64,536 | Oct 2023 |
-| `gpt-4o` <sup>**1**</sup> (2024-08-06) | East US2 <br> North Central US <br> Sweden Central | Input: 128,000 <br> Output: 16,384  <br> Training example context length: 64,536 | Oct 2023 | 
+| `gpt-4o-mini` (2024-07-18) | North Central US <br> Sweden Central | Input: 128,000 <br> Output: 16,384  <br> Training example context length: 64,536 | Oct 2023 |
+| `gpt-4o` (2024-08-06) | East US2 <br> North Central US <br> Sweden Central | Input: 128,000 <br> Output: 16,384  <br> Training example context length: 64,536 | Oct 2023 | 
 
 **<sup>1</sup>** GPT-4 is currently in public preview.

@@ -22,4 +22,4 @@ keywords: ChatGPT
 > As described in [Azure OpenAI Service pricing](https://azure.microsoft.com/pricing/details/cognitive-services/openai-service/),
 > each customized (fine-tuned) model that's deployed incurs an hourly hosting cost regardless of whether completions
 > or chat completions calls are being made to the model. To learn more about planning and managing costs with Azure OpenAI,
-> refer to the guidance in [Plan to manage costs for Azure OpenAI Service](../how-to/manage-costs.md#base-series-and-codex-series-fine-tuned-models).
\ No newline at end of file
+> refer to the guidance in [Plan to manage costs for Azure OpenAI Service](../how-to/manage-costs.md#fine-tuned-models).
\ No newline at end of file

@@ -80,7 +80,7 @@ If you would like a step-by-step walk-through of fine-tuning a `gpt-35-turbo-061
 {"messages": [{"role": "system", "content": "You are an Xbox customer support agent whose primary goal is to help users with issues they are experiencing with their Xbox devices. You are friendly and concise. You only provide factual answers to queries, and do not provide answers that are not related to Xbox."}, {"role": "user", "content": "I'm having trouble connecting my Xbox to the Wi-Fi."}, {"role": "assistant", "content": "No worries, let's go through the network settings on your Xbox. Can you please tell me what happens when you try to connect it to the Wi-Fi?"}]}
 ```
 
-## Multi-turn chat file format
+### Multi-turn chat file format
 
 Multiple turns of a conversation in a single line of your jsonl training file is also supported. To skip fine-tuning on specific assistant messages add the optional `weight` key value pair. Currently `weight` can be set to 0 or 1.  
 
@@ -90,6 +90,12 @@ Multiple turns of a conversation in a single line of your jsonl training file is
 {"messages": [{"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "How far is the Moon from Earth?"}, {"role": "assistant", "content": "384,400 kilometers", "weight": 0}, {"role": "user", "content": "Can you be more sarcastic?"}, {"role": "assistant", "content": "Around 384,400 kilometers. Give or take a few, like that really matters.", "weight": 1}]}
 ```
 
+### Chat completions with vision
+
+```json
+{"messages": [{"role": "user", "content": [{"type": "text", "text": "What's in this image?"}, {"type": "image_url", "image_url": {"url": "https://raw.githubusercontent.com/MicrosoftDocs/azure-ai-docs/main/articles/ai-services/openai/media/how-to/generated-seattle.png"}}]}, {"role": "assistant", "content": "The image appears to be a watercolor painting of a city skyline, featuring tall buildings and a recognizable structure often associated with Seattle, like the Space Needle. The artwork uses soft colors and brushstrokes to create a somewhat abstract and artistic representation of the cityscape."}]}
+```
+
 In addition to the JSONL format, training and validation data files must be encoded in UTF-8 and include a byte-order mark (BOM). The file must be less than 512 MB in size.
 
 ### Create your training and validation datasets

@@ -86,11 +86,17 @@ Multiple turns of a conversation in a single line of your jsonl training file is
 {"messages": [{"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "How far is the Moon from Earth?"}, {"role": "assistant", "content": "384,400 kilometers", "weight": 0}, {"role": "user", "content": "Can you be more sarcastic?"}, {"role": "assistant", "content": "Around 384,400 kilometers. Give or take a few, like that really matters.", "weight": 1}]}
 ```
 
+### Chat completions with vision
+
+```json
+{"messages": [{"role": "user", "content": [{"type": "text", "text": "What's in this image?"}, {"type": "image_url", "image_url": {"url": "https://raw.githubusercontent.com/MicrosoftDocs/azure-ai-docs/main/articles/ai-services/openai/media/how-to/generated-seattle.png"}}]}, {"role": "assistant", "content": "The image appears to be a watercolor painting of a city skyline, featuring tall buildings and a recognizable structure often associated with Seattle, like the Space Needle. The artwork uses soft colors and brushstrokes to create a somewhat abstract and artistic representation of the cityscape."}]}
+```
+
 In addition to the JSONL format, training and validation data files must be encoded in UTF-8 and include a byte-order mark (BOM). The file must be less than 512 MB in size.
 
 ### Create your training and validation datasets
 
-The more training examples you have, the better. Fine tuning jobs will not proceed without at least 10 training examples, but such a small number are not enough to noticeably influence model responses. It is best practice to provide hundreds, if not thousands, of training examples to be successful.
+The more training examples you have, the better. Fine tuning jobs will not proceed without at least 10 training examples, but such a small number is not enough to noticeably influence model responses. It is best practice to provide hundreds, if not thousands, of training examples to be successful.
 
 In general, doubling the dataset size can lead to a linear increase in model quality. But keep in mind, low quality examples can negatively impact performance. If you train the model on a large amount of internal data, without first pruning the dataset for only the highest quality examples you could end up with a model that performs much worse than expected.
 
@@ -110,7 +116,7 @@ In addition to the JSONL format, training and validation data files must be enco
 
 Designing your prompts and completions for fine-tuning is different from designing your prompts for use with any of [our GPT-3 base models](../concepts/legacy-models.md#gpt-3-models). Prompts for completion calls often use either detailed instructions or few-shot learning techniques, and consist of multiple examples. For fine-tuning, each training example should consist of a single input prompt and its desired completion output. You don't need to give detailed instructions or multiple completion examples for the same prompt.
 
-The more training examples you have, the better. Fine tuning jobs will not proceed without at least 10 training examples, but such a small number are not enough to noticeably influence model responses. It is best practice to provide hundreds, if not thousands, of training examples to be successful.
+The more training examples you have, the better. Fine tuning jobs will not proceed without at least 10 training examples, but such a small number is not enough to noticeably influence model responses. It is best practice to provide hundreds, if not thousands, of training examples to be successful.
 
 In general, doubling the dataset size can lead to a linear increase in model quality. But keep in mind, low quality examples can negatively impact performance. If you train the model on a large amount of internal data, without first pruning the dataset for only the highest quality examples you could end up with a model that performs much worse than expected.
 

@@ -85,12 +85,18 @@ Multiple turns of a conversation in a single line of your jsonl training file is
 {"messages": [{"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "How far is the Moon from Earth?"}, {"role": "assistant", "content": "384,400 kilometers", "weight": 0}, {"role": "user", "content": "Can you be more sarcastic?"}, {"role": "assistant", "content": "Around 384,400 kilometers. Give or take a few, like that really matters.", "weight": 1}]}
 ```
 
+### Chat completions with vision
+
+```json
+{"messages": [{"role": "user", "content": [{"type": "text", "text": "What's in this image?"}, {"type": "image_url", "image_url": {"url": "https://raw.githubusercontent.com/MicrosoftDocs/azure-ai-docs/main/articles/ai-services/openai/media/how-to/generated-seattle.png"}}]}, {"role": "assistant", "content": "The image appears to be a watercolor painting of a city skyline, featuring tall buildings and a recognizable structure often associated with Seattle, like the Space Needle. The artwork uses soft colors and brushstrokes to create a somewhat abstract and artistic representation of the cityscape."}]}
+```
+
 In addition to the JSONL format, training and validation data files must be encoded in UTF-8 and include a byte-order mark (BOM). The file must be less than 512 MB in size.
 
 
 ### Create your training and validation datasets
 
-The more training examples you have, the better. Fine tuning jobs will not proceed without at least 10 training examples, but such a small number are not enough to noticeably influence model responses. It is best practice to provide hundreds, if not thousands, of training examples to be successful.
+The more training examples you have, the better. Fine tuning jobs will not proceed without at least 10 training examples, but such a small number is not enough to noticeably influence model responses. It is best practice to provide hundreds, if not thousands, of training examples to be successful.
 
 In general, doubling the dataset size can lead to a linear increase in model quality. But keep in mind, low quality examples can negatively impact performance. If you train the model on a large amount of internal data without first pruning the dataset for only the highest quality examples, you could end up with a model that performs much worse than expected.
 
@@ -110,7 +116,7 @@ In addition to the JSONL format, training and validation data files must be enco
 
 Designing your prompts and completions for fine-tuning is different from designing your prompts for use with any of [our GPT-3 base models](../concepts/legacy-models.md#gpt-3-models). Prompts for completion calls often use either detailed instructions or few-shot learning techniques, and consist of multiple examples. For fine-tuning, each training example should consist of a single input prompt and its desired completion output. You don't need to give detailed instructions or multiple completion examples for the same prompt.
 
-The more training examples you have, the better. Fine tuning jobs will not proceed without at least 10 training examples, but such a small number are not enough to noticeably influence model responses. It is best practice to provide hundreds, if not thousands, of training examples to be successful.
+The more training examples you have, the better. Fine tuning jobs will not proceed without at least 10 training examples, but such a small number is not enough to noticeably influence model responses. It is best practice to provide hundreds, if not thousands, of training examples to be successful.
 
 In general, doubling the dataset size can lead to a linear increase in model quality. But keep in mind, low quality examples can negatively impact performance. If you train the model on a large amount of internal data without first pruning the dataset for only the highest quality examples, you could end up with a model that performs much worse than expected.
 

@@ -76,7 +76,7 @@ If you would like a step-by-step walk-through of fine-tuning a `gpt-4o-mini` (20
 {"messages": [{"role": "system", "content": "You are an Xbox customer support agent whose primary goal is to help users with issues they are experiencing with their Xbox devices. You are friendly and concise. You only provide factual answers to queries, and do not provide answers that are not related to Xbox."}, {"role": "user", "content": "I'm having trouble connecting my Xbox to the Wi-Fi."}, {"role": "assistant", "content": "No worries, let's go through the network settings on your Xbox. Can you please tell me what happens when you try to connect it to the Wi-Fi?"}]}
 ```
 
-## Multi-turn chat file format Azure OpenAI 
+### Multi-turn chat file format Azure OpenAI 
 
 Multiple turns of a conversation in a single line of your jsonl training file is also supported. To skip fine-tuning on specific assistant messages add the optional `weight` key value pair. Currently `weight` can be set to 0 or 1.  
 
@@ -86,6 +86,12 @@ Multiple turns of a conversation in a single line of your jsonl training file is
 {"messages": [{"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "How far is the Moon from Earth?"}, {"role": "assistant", "content": "384,400 kilometers", "weight": 0}, {"role": "user", "content": "Can you be more sarcastic?"}, {"role": "assistant", "content": "Around 384,400 kilometers. Give or take a few, like that really matters.", "weight": 1}]}
 ```
 
+### Chat completions with vision
+
+```json
+{"messages": [{"role": "user", "content": [{"type": "text", "text": "What's in this image?"}, {"type": "image_url", "image_url": {"url": "https://raw.githubusercontent.com/MicrosoftDocs/azure-ai-docs/main/articles/ai-services/openai/media/how-to/generated-seattle.png"}}]}, {"role": "assistant", "content": "The image appears to be a watercolor painting of a city skyline, featuring tall buildings and a recognizable structure often associated with Seattle, like the Space Needle. The artwork uses soft colors and brushstrokes to create a somewhat abstract and artistic representation of the cityscape."}]}
+```
+
 In addition to the JSONL format, training and validation data files must be encoded in UTF-8 and include a byte-order mark (BOM). The file must be less than 512 MB in size.
 
 ### Create your training and validation datasets

@@ -1,7 +1,7 @@
 ---
 title: 'Quickstart: Use GPT-4 Turbo with Vision on your images and videos with the Azure OpenAI Service'
 titleSuffix: Azure OpenAI
-description: Use this article to get started using Azure OpenAI Studio to deploy and use the GPT-4 Turbo with Vision model.  
+description: Use this article to get started using Azure AI Studio to deploy and use the GPT-4 Turbo with Vision model.  
 services: cognitive-services
 manager: nitinme
 ms.service: azure-ai-openai
@@ -10,7 +10,7 @@ ms.custom: references_regions
 ms.date: 10/03/2024
 ---
 
-Start exploring GPT-4 Turbo with Vision capabilities with a no-code approach through Azure OpenAI Studio.
+Start exploring GPT-4 Turbo with Vision capabilities with a no-code approach through Azure AI Studio.
 
 ## Prerequisites
 
@@ -20,9 +20,9 @@ Start exploring GPT-4 Turbo with Vision capabilities with a no-code approach thr
 > [!NOTE]
 > It is currently not supported to turn off content filtering for the GPT-4 Turbo with Vision model.
 
-## Go to Azure OpenAI Studio
+## Go to Azure AI Studio
 
-Browse to [Azure OpenAI Studio](https://oai.azure.com/) and sign in with the credentials associated with your Azure OpenAI resource. During or after the sign-in workflow, select the appropriate directory, Azure subscription, and Azure OpenAI resource.
+Browse to [Azure AI Studio](https://ai.azure.com/) and sign in with the credentials associated with your Azure OpenAI resource. During or after the sign-in workflow, select the appropriate directory, Azure subscription, and Azure OpenAI resource.
 
 Under **Management** select **Deployments** and **Create** a GPT-4 Turbo with Vision deployment by selecting model name: **"gpt-4"** and model version **"vision-preview"**. For more information about model deployment, see the [resource deployment guide](/azure/ai-services/openai/how-to/create-resource).  
 
@@ -50,7 +50,7 @@ In this chat session, you're instructing the assistant to aid in understanding i
 1. In the **Chat session** pane, enter a text prompt like "Describe this image," and upload an image with the attachment button. You can use a different text prompt for your use case. Then select **Send**. 
 1. Observe the output provided. Consider asking follow-up questions related to the analysis of your image to learn more.
 
-:::image type="content" source="../media/quickstarts/studio-vision.png" lightbox="../media/quickstarts/studio-vision.png" alt-text="Screenshot of OpenAI studio chat playground.":::
+:::image type="content" source="../media/quickstarts/studio-vision.png" lightbox="../media/quickstarts/studio-vision.png" alt-text="Screenshot of AI studio chat playground.":::
 
 
 ## Clean up resources

@@ -0,0 +1,298 @@
+---
+title: Azure OpenAI C# support
+titleSuffix: Azure OpenAI Service
+description: Azure OpenAI C# support
+manager: nitinme
+ms.service: azure-ai-openai
+ms.topic: include
+ms.date: 11/18/2024
+---
+
+
+The Azure OpenAI client library for .NET is a companion to the [official OpenAI client library for .NET](https://github.com/openai/openai-dotnet). The Azure OpenAI library configures a client for use with Azure OpenAI and provides additional strongly typed extension support for request and response models specific to Azure OpenAI scenarios.
+
+### Stable release: 
+
+[Source code](https://github.com/Azure/azure-sdk-for-net/blob/Azure.AI.OpenAI_2.0.0/sdk/openai/Azure.AI.OpenAI/src) | [Package (NuGet)](https://www.nuget.org/packages/Azure.AI.OpenAI) | [Package reference documentation](/dotnet/api/overview/azure/ai.openai-readme?view=azure-dotnet&preserve-view=true) [API reference documentation](../../reference.md) |  [Samples](https://github.com/Azure/azure-sdk-for-net/blob/Azure.AI.OpenAI_2.0.0/sdk/openai/Azure.AI.OpenAI/tests/Samples)
+ 
+### Preview release: 
+
+The preview release will have access to the latest features.
+
+[Source code](https://github.com/Azure/azure-sdk-for-net/tree/Azure.AI.OpenAI_2.1.0-beta.2/sdk/openai/Azure.AI.OpenAI/src) | [Package (NuGet)](https://www.nuget.org/packages/Azure.AI.OpenAI/2.1.0-beta.2) | [API reference documentation](../../reference.md) | [Package reference documentation](/dotnet/api/overview/azure/ai.openai-readme?view=azure-dotnet-preview&preserve-view=true)   [Samples](https://github.com/Azure/azure-sdk-for-net/tree/Azure.AI.OpenAI_2.1.0-beta.2/sdk/openai/Azure.AI.OpenAI/tests/Samples)
+
+
+## Azure OpenAI API version support
+
+Unlike the Azure OpenAI client libraries for Python and JavaScript, the Azure OpenAI .NET package is limited to targeting a specific subset of the Azure OpenAI API versions. Generally each Azure OpenAI .NET package will unlock access to newer Azure OpenAI API release features. Having access to the latest API versions impacts feature availability.
+
+Version selection is controlled by the [`AzureOpenAIClientOptions.ServiceVersion`](/dotnet/api/azure.ai.openai.azureopenaiclientoptions.serviceversion?view=azure-dotnet&preserve-view=true) enum.
+
+The [stable release](/dotnet/api/azure.ai.openai.azureopenaiclientoptions.serviceversion?view=azure-dotnet&preserve-view=true) currently targets:
+
+`2024-06-01`
+
+The [preview release](/dotnet/api/azure.ai.openai.azureopenaiclientoptions.serviceversion?view=azure-dotnet-preview&preserve-view=true) can currently target:
+
+- `2024-06-01`
+- `2024-08-01-preview`
+- `2024-09-01-preview`
+- `2024-10-01-preview`
+
+## Installation
+
+```dotnetcli
+dotnet add package Azure.AI.OpenAI --prerelease
+```
+
+The `Azure.AI.OpenAI` package builds on the [official OpenAI package](https://www.nuget.org/packages/OpenAI), which is included as a dependency.
+
+## Authentication
+
+To interact with Azure OpenAI or OpenAI, create an instance of [`AzureOpenAIClient`](/dotnet/api/azure.ai.openai.azureopenaiclient?view=azure-dotnet-preview&preserve-view=true) with one of the following approaches:
+
+# [Microsoft Entra ID](#tab/dotnet-secure)
+
+A secure, keyless authentication approach is to use Microsoft Entra ID (formerly Azure Active Directory) via the [Azure Identity library](/dotnet/api/overview/azure/identity-readme?view=azure-dotnet&preserve-view=true ). To use the library:
+
+```dotnetcli
+dotnet add package Azure.Identity
+```
+
+Use the desired credential type from the library. For example, [`DefaultAzureCredential`](/dotnet/api/azure.identity.defaultazurecredential?view=azure-dotnet&preserve-view=true):
+
+```csharp
+AzureOpenAIClient azureClient = new(
+    new Uri("https://your-azure-openai-resource.com"),
+    new DefaultAzureCredential());
+ChatClient chatClient = azureClient.GetChatClient("my-gpt-4o-mini-deployment");
+```
+
+# [API Key](#tab/dotnet-key)
+
+```csharp
+string keyFromEnvironment = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY");
+
+AzureOpenAIClient azureClient = new(
+    new Uri("https://your-azure-openai-resource.com"),
+    new ApiKeyCredential(keyFromEnvironment));
+ChatClient chatClient = azureClient.GetChatClient("my-gpt-35-turbo-deployment");
+```
+
+---
+
+## Audio
+
+[`AzureOpenAIClient.GetAudioClient`](/dotnet/api/azure.ai.openai.azureopenaiclient.getaudioclient?view=azure-dotnet-preview&preserve-view=true )
+
+### Transcription
+
+```csharp
+AzureOpenAIClient azureClient = new(
+    new Uri("https://your-azure-openai-resource.com"),
+    new DefaultAzureCredential());
+
+AudioClient client = azureClient.GetAudioClient("whisper");
+
+string audioFilePath = Path.Combine("Assets", "speech.mp3");
+
+AudioTranscriptionOptions options = new()
+{
+    ResponseFormat = AudioTranscriptionFormat.Verbose,
+    TimestampGranularities = AudioTimestampGranularities.Word | AudioTimestampGranularities.Segment,
+};
+
+AudioTranscription transcription = client.TranscribeAudio(audioFilePath, options);
+
+Console.WriteLine("Transcription:");
+Console.WriteLine($"{transcription.Text}");
+
+Console.WriteLine();
+Console.WriteLine($"Words:");
+foreach (TranscribedWord word in transcription.Words)
+{
+    Console.WriteLine($"  {word.Word,15} : {word.StartTime.TotalMilliseconds,5:0} - {word.EndTime.TotalMilliseconds,5:0}");
+}
+
+Console.WriteLine();
+Console.WriteLine($"Segments:");
+foreach (TranscribedSegment segment in transcription.Segments)
+{
+    Console.WriteLine($"  {segment.Text,90} : {segment.StartTime.TotalMilliseconds,5:0} - {segment.EndTime.TotalMilliseconds,5:0}");
+}
+```
+
+### Text to Speech (TTS)
+
+```csharp
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using OpenAI.Audio;
+
+AzureOpenAIClient azureClient = new(
+    new Uri("https://your-azure-openai-resource.com"),
+    new DefaultAzureCredential());
+
+AudioClient client = azureClient.GetAudioClient("tts-hd"); //Replace with your Azure OpenAI model deployment
+
+string input = "Testing, testing, 1, 2, 3";
+
+BinaryData speech = client.GenerateSpeech(input, GeneratedSpeechVoice.Alloy);
+
+using FileStream stream = File.OpenWrite($"{Guid.NewGuid()}.mp3");
+speech.ToStream().CopyTo(stream);
+```
+
+## Chat
+
+[`AzureOpenAIClient.GetChatClient`](/dotnet/api/azure.ai.openai.azureopenaiclient.getchatclient?view=azure-dotnet-preview&preserve-view=true)
+
+```csharp
+AzureOpenAIClient azureClient = new(
+    new Uri("https://your-azure-openai-resource.com"),
+    new DefaultAzureCredential());
+ChatClient chatClient = azureClient.GetChatClient("my-gpt-4o-deployment");
+
+ChatCompletion completion = chatClient.CompleteChat(
+    [
+        // System messages represent instructions or other guidance about how the assistant should behave
+        new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
+        // User messages represent user input, whether historical or the most recent input
+        new UserChatMessage("Hi, can you help me?"),
+        // Assistant messages in a request represent conversation history for responses
+        new AssistantChatMessage("Arrr! Of course, me hearty! What can I do for ye?"),
+        new UserChatMessage("What's the best way to train a parrot?"),
+    ]);
+
+Console.WriteLine($"{completion.Role}: {completion.Content[0].Text}");
+```
+
+### Stream chat messages
+
+Streaming chat completions use the `CompleteChatStreaming` and `CompleteChatStreamingAsync` method, which return a `ResultCollection<StreamingChatCompletionUpdate>` or `AsyncCollectionResult<StreamingChatCompletionUpdate>` instead of a `ClientResult<ChatCompletion>`. 
+
+These result collections can be iterated over using foreach or await foreach, with each update arriving as new data is available from the streamed response.
+
+```csharp
+AzureOpenAIClient azureClient = new(
+    new Uri("https://your-azure-openai-resource.com"),
+    new DefaultAzureCredential());
+ChatClient chatClient = azureClient.GetChatClient("my-gpt-4o-deployment");
+
+CollectionResult<StreamingChatCompletionUpdate> completionUpdates = chatClient.CompleteChatStreaming(
+    [
+        new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
+        new UserChatMessage("Hi, can you help me?"),
+        new AssistantChatMessage("Arrr! Of course, me hearty! What can I do for ye?"),
+        new UserChatMessage("What's the best way to train a parrot?"),
+    ]);
+
+foreach (StreamingChatCompletionUpdate completionUpdate in completionUpdates)
+{
+    foreach (ChatMessageContentPart contentPart in completionUpdate.ContentUpdate)
+    {
+        Console.Write(contentPart.Text);
+    }
+}
+```
+
+## Embeddings
+
+[`AzureOpenAIClient.GetEmbeddingClient`](/dotnet/api/azure.ai.openai.azureopenaiclient.getembeddingclient?view=azure-dotnet-preview&preserve-view=true)
+
+```csharp
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using OpenAI.Embeddings;
+
+AzureOpenAIClient azureClient = new(
+    new Uri("https://your-azure-openai-resource.com"),
+    new DefaultAzureCredential());
+
+EmbeddingClient client = azureClient.GetEmbeddingClient("text-embedding-3-large"); //Replace with your model deployment name
+
+string description = "This is a test embedding";
+
+OpenAIEmbedding embedding = client.GenerateEmbedding(description);
+ReadOnlyMemory<float> vector = embedding.ToFloats();
+
+Console.WriteLine(string.Join(", ", vector.ToArray()));
+```
+
+## Fine-tuning
+
+Currently not supported with the Azure OpenAI .NET packages.
+
+## Batch
+
+Currently not supported with the Azure OpenAI .NET packages.
+
+## Images
+
+[`AzureOpenAIClient.GetImageClient`](/dotnet/api/azure.ai.openai.azureopenaiclient.getimageclient?view=azure-dotnet-preview&preserve-view=true)
+
+```csharp
+using Azure.AI.OpenAI;
+using Azure.Identity;
+using OpenAI.Images;
+
+AzureOpenAIClient azureClient = new(
+    new Uri("https://your-azure-openai-resource.com"),
+    new DefaultAzureCredential());
+
+ImageClient client = azureClient.GetImageClient("dall-e-3"); // replace with your model deployment name.
+
+string prompt = "A rabbit eating pancakes.";
+
+ImageGenerationOptions options = new()
+{
+     Quality = GeneratedImageQuality.High,
+     Size = GeneratedImageSize.W1792xH1024,
+     Style = GeneratedImageStyle.Vivid,
+     ResponseFormat = GeneratedImageFormat.Bytes
+};
+
+GeneratedImage image = client.GenerateImage(prompt, options);
+BinaryData bytes = image.ImageBytes;
+
+using FileStream stream = File.OpenWrite($"{Guid.NewGuid()}.png");
+bytes.ToStream().CopyTo(stream);
+
+```
+
+- [C# DALL-E quickstart guide](/azure/ai-services/openai/dall-e-quickstart?tabs=dalle3%2Ccommand-line%2Cjavascript-keyless%2Ctypescript-keyless&pivots=programming-language-csharp)
+
+
+## Completions (legacy)
+
+Not supported with the Azure OpenAI .NET packages.
+
+
+## Error handling
+
+### Error codes
+
+| Status Code | Error Type |
+|----|---|
+| 400         | `Bad Request Error`          |
+| 401         | `Authentication Error`      |
+| 403         | `Permission Denied Error`    |
+| 404         | `Not Found Error`            |
+| 422         | `Unprocessable Entity Error` |
+| 429         | `Rate Limit Error`           |
+| 500         | `Internal Server Error`      |
+| 503         | `Service Unavailable`       |
+| 504         | `Gateway Timeout` |
+
+### Retries
+
+The client classes will automatically retry the following errors up to three additional times using exponential backoff:
+
+- 408 Request Timeout
+- 429 Too Many Requests
+- 500 Internal Server Error
+- 502 Bad Gateway
+- 503 Service Unavailable
+- 504 Gateway Timeout
+
+

@@ -0,0 +1,683 @@
+---
+title: Azure OpenAI Go support
+titleSuffix: Azure OpenAI Service
+description: Azure OpenAI Go support
+manager: nitinme
+ms.service: azure-ai-openai
+ms.topic: include
+ms.date: 11/18/2024
+---
+
+[Source code](https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/ai/azopenai) | [Package (pkg.go.dev)](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai) | [API reference documentation](../../reference.md) | [Package reference documentation](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai)   [Samples](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai#pkg-examples)
+
+
+## Azure OpenAI API version support
+
+Unlike the Azure OpenAI client libraries for Python and JavaScript, the Azure OpenAI Go library is targeted to a specific Azure OpenAI API version. Having access to the latest API versions impacts feature availability.
+
+Current Azure OpenAI API version target: `2024-10-01-preview`
+
+This is defined in the [**custom_client.go**](https://github.com/Azure/azure-sdk-for-go/blob/9ebef43f64796118ae206a42821d9f541a231daa/sdk/ai/azopenai/custom_client.go#L37) file.
+
+## Installation
+
+Install the `azopenai` and `azidentity` modules with go get:
+
+```
+go get github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai
+
+# optional
+go get github.com/Azure/azure-sdk-for-go/sdk/azidentity
+```
+
+## Authentication
+
+# [Microsoft Entra ID](#tab/secure)
+
+The [azidentity](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity) module is used for Azure Active Directory authentication with Azure OpenAI.
+
+```go
+package main
+
+import (
+	"log"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
+	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
+)
+
+func main() {
+	dac, err := azidentity.NewDefaultAzureCredential(nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	// NOTE: this constructor creates a client that connects to an Azure OpenAI endpoint.
+	// To connect to the public OpenAI endpoint, use azopenai.NewClientForOpenAI
+	client, err := azopenai.NewClient("https://<your-azure-openai-host>.openai.azure.com", dac, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	_ = client
+}
+```
+
+
+# [API Key](#tab/api-key)
+
+```go
+package main
+
+import (
+	"log"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+)
+
+func main() {
+	keyCredential := azcore.NewKeyCredential("<Azure-OpenAI-APIKey>")
+
+	// NOTE: this constructor creates a client that connects to an Azure OpenAI endpoint.
+	// To connect to the public OpenAI endpoint, use azopenai.NewClientForOpenAI
+	client, err := azopenai.NewClientWithKeyCredential("https://<your-azure-openai-host>.openai.azure.com", keyCredential, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	_ = client
+}
+```
+
+---
+
+## Audio
+
+### Client.GenerateSpeechFromText
+
+```go
+ackage main
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"os"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
+)
+
+func main() {
+	openAIKey := os.Getenv("OPENAI_API_KEY")
+
+	// Ex: "https://api.openai.com/v1"
+	openAIEndpoint := os.Getenv("OPENAI_ENDPOINT")
+
+	modelDeploymentID := "tts-1"
+
+	if openAIKey == "" || openAIEndpoint == "" || modelDeploymentID == "" {
+		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
+		return
+	}
+
+	keyCredential := azcore.NewKeyCredential(openAIKey)
+
+	client, err := azopenai.NewClientForOpenAI(openAIEndpoint, keyCredential, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	audioResp, err := client.GenerateSpeechFromText(context.Background(), azopenai.SpeechGenerationOptions{
+		Input:          to.Ptr("i am a computer"),
+		Voice:          to.Ptr(azopenai.SpeechVoiceAlloy),
+		ResponseFormat: to.Ptr(azopenai.SpeechGenerationResponseFormatFlac),
+		DeploymentName: to.Ptr("tts-1"),
+	}, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	defer audioResp.Body.Close()
+
+	audioBytes, err := io.ReadAll(audioResp.Body)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	fmt.Fprintf(os.Stderr, "Got %d bytes of FLAC audio\n", len(audioBytes))
+
+}
+
+```
+
+### Client.GetAudioTranscription
+
+```go
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
+)
+
+func main() {
+	azureOpenAIKey := os.Getenv("AOAI_WHISPER_API_KEY")
+
+	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
+	azureOpenAIEndpoint := os.Getenv("AOAI_WHISPER_ENDPOINT")
+
+	modelDeploymentID := os.Getenv("AOAI_WHISPER_MODEL")
+
+	if azureOpenAIKey == "" || azureOpenAIEndpoint == "" || modelDeploymentID == "" {
+		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
+		return
+	}
+
+	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)
+
+	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	mp3Bytes, err := os.ReadFile("testdata/sampledata_audiofiles_myVoiceIsMyPassportVerifyMe01.mp3")
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	resp, err := client.GetAudioTranscription(context.TODO(), azopenai.AudioTranscriptionOptions{
+		File: mp3Bytes,
+
+		// this will return _just_ the translated text. Other formats are available, which return
+		// different or additional metadata. See [azopenai.AudioTranscriptionFormat] for more examples.
+		ResponseFormat: to.Ptr(azopenai.AudioTranscriptionFormatText),
+
+		DeploymentName: &modelDeploymentID,
+	}, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	fmt.Fprintf(os.Stderr, "Transcribed text: %s\n", *resp.Text)
+
+}
+```
+
+## Chat
+
+### Client.GetChatCompletions
+
+```go
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+)
+
+func main() {
+	azureOpenAIKey := os.Getenv("AOAI_CHAT_COMPLETIONS_API_KEY")
+	modelDeploymentID := os.Getenv("AOAI_CHAT_COMPLETIONS_MODEL")
+
+	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
+	azureOpenAIEndpoint := os.Getenv("AOAI_CHAT_COMPLETIONS_ENDPOINT")
+
+	if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
+		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
+		return
+	}
+
+	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)
+
+	// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
+	// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
+	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	// This is a conversation in progress.
+	// NOTE: all messages, regardless of role, count against token usage for this API.
+	messages := []azopenai.ChatRequestMessageClassification{
+		// You set the tone and rules of the conversation with a prompt as the system role.
+		&azopenai.ChatRequestSystemMessage{Content: azopenai.NewChatRequestSystemMessageContent("You are a helpful assistant. You will talk like a pirate.")},
+
+		// The user asks a question
+		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("Can you help me?")},
+
+		// The reply would come back from the ChatGPT. You'd add it to the conversation so we can maintain context.
+		&azopenai.ChatRequestAssistantMessage{Content: azopenai.NewChatRequestAssistantMessageContent("Arrrr! Of course, me hearty! What can I do for ye?")},
+
+		// The user answers the question based on the latest reply.
+		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("What's the best way to train a parrot?")},
+
+		// from here you'd keep iterating, sending responses back from ChatGPT
+	}
+
+	gotReply := false
+
+	resp, err := client.GetChatCompletions(context.TODO(), azopenai.ChatCompletionsOptions{
+		// This is a conversation in progress.
+		// NOTE: all messages count against token usage for this API.
+		Messages:       messages,
+		DeploymentName: &modelDeploymentID,
+	}, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	for _, choice := range resp.Choices {
+		gotReply = true
+
+		if choice.ContentFilterResults != nil {
+			fmt.Fprintf(os.Stderr, "Content filter results\n")
+
+			if choice.ContentFilterResults.Error != nil {
+				fmt.Fprintf(os.Stderr, "  Error:%v\n", choice.ContentFilterResults.Error)
+			}
+
+			fmt.Fprintf(os.Stderr, "  Hate: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Hate.Severity, *choice.ContentFilterResults.Hate.Filtered)
+			fmt.Fprintf(os.Stderr, "  SelfHarm: sev: %v, filtered: %v\n", *choice.ContentFilterResults.SelfHarm.Severity, *choice.ContentFilterResults.SelfHarm.Filtered)
+			fmt.Fprintf(os.Stderr, "  Sexual: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Sexual.Severity, *choice.ContentFilterResults.Sexual.Filtered)
+			fmt.Fprintf(os.Stderr, "  Violence: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Violence.Severity, *choice.ContentFilterResults.Violence.Filtered)
+		}
+
+		if choice.Message != nil && choice.Message.Content != nil {
+			fmt.Fprintf(os.Stderr, "Content[%d]: %s\n", *choice.Index, *choice.Message.Content)
+		}
+
+		if choice.FinishReason != nil {
+			// this choice's conversation is complete.
+			fmt.Fprintf(os.Stderr, "Finish reason[%d]: %s\n", *choice.Index, *choice.FinishReason)
+		}
+	}
+
+	if gotReply {
+		fmt.Fprintf(os.Stderr, "Got chat completions reply\n")
+	}
+
+}
+
+```
+
+### Client.GetChatCompletionsStream
+
+```go
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"os"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
+)
+
+func main() {
+	azureOpenAIKey := os.Getenv("AOAI_CHAT_COMPLETIONS_API_KEY")
+	modelDeploymentID := os.Getenv("AOAI_CHAT_COMPLETIONS_MODEL")
+
+	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
+	azureOpenAIEndpoint := os.Getenv("AOAI_CHAT_COMPLETIONS_ENDPOINT")
+
+	if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
+		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
+		return
+	}
+
+	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)
+
+	// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
+	// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
+	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	// This is a conversation in progress.
+	// NOTE: all messages, regardless of role, count against token usage for this API.
+	messages := []azopenai.ChatRequestMessageClassification{
+		// You set the tone and rules of the conversation with a prompt as the system role.
+		&azopenai.ChatRequestSystemMessage{Content: azopenai.NewChatRequestSystemMessageContent("You are a helpful assistant. You will talk like a pirate and limit your responses to 20 words or less.")},
+
+		// The user asks a question
+		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("Can you help me?")},
+
+		// The reply would come back from the ChatGPT. You'd add it to the conversation so we can maintain context.
+		&azopenai.ChatRequestAssistantMessage{Content: azopenai.NewChatRequestAssistantMessageContent("Arrrr! Of course, me hearty! What can I do for ye?")},
+
+		// The user answers the question based on the latest reply.
+		&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("What's the best way to train a parrot?")},
+
+		// from here you'd keep iterating, sending responses back from ChatGPT
+	}
+
+	resp, err := client.GetChatCompletionsStream(context.TODO(), azopenai.ChatCompletionsStreamOptions{
+		// This is a conversation in progress.
+		// NOTE: all messages count against token usage for this API.
+		Messages:       messages,
+		N:              to.Ptr[int32](1),
+		DeploymentName: &modelDeploymentID,
+	}, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	defer resp.ChatCompletionsStream.Close()
+
+	gotReply := false
+
+	for {
+		chatCompletions, err := resp.ChatCompletionsStream.Read()
+
+		if errors.Is(err, io.EOF) {
+			break
+		}
+
+		if err != nil {
+			//  TODO: Update the following line with your application specific error handling logic
+			log.Printf("ERROR: %s", err)
+			return
+		}
+
+		for _, choice := range chatCompletions.Choices {
+			gotReply = true
+
+			text := ""
+
+			if choice.Delta.Content != nil {
+				text = *choice.Delta.Content
+			}
+
+			role := ""
+
+			if choice.Delta.Role != nil {
+				role = string(*choice.Delta.Role)
+			}
+
+			fmt.Fprintf(os.Stderr, "Content[%d], role %q: %q\n", *choice.Index, role, text)
+		}
+	}
+
+	if gotReply {
+		fmt.Fprintf(os.Stderr, "Got chat completions streaming reply\n")
+	}
+
+}
+```
+
+## Embeddings
+
+### Client.GetEmbeddings
+
+```go
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+)
+
+func main() {
+	azureOpenAIKey := os.Getenv("AOAI_EMBEDDINGS_API_KEY")
+	modelDeploymentID := os.Getenv("AOAI_EMBEDDINGS_MODEL")
+
+	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
+	azureOpenAIEndpoint := os.Getenv("AOAI_EMBEDDINGS_ENDPOINT")
+
+	if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
+		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
+		return
+	}
+
+	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)
+
+	// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
+	// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
+	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	resp, err := client.GetEmbeddings(context.TODO(), azopenai.EmbeddingsOptions{
+		Input:          []string{"Testing, testing, 1,2,3."},
+		DeploymentName: &modelDeploymentID,
+	}, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	for _, embed := range resp.Data {
+		// embed.Embedding contains the embeddings for this input index.
+		fmt.Fprintf(os.Stderr, "Got embeddings for input %d\n", *embed.Index)
+	}
+
+}
+```
+
+## Image Generation
+
+### Client.GetImageGenerations
+
+```go
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
+)
+
+func main() {
+	azureOpenAIKey := os.Getenv("AOAI_DALLE_API_KEY")
+
+	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
+	azureOpenAIEndpoint := os.Getenv("AOAI_DALLE_ENDPOINT")
+
+	azureDeployment := os.Getenv("AOAI_DALLE_MODEL")
+
+	if azureOpenAIKey == "" || azureOpenAIEndpoint == "" || azureDeployment == "" {
+		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
+		return
+	}
+
+	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)
+
+	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	resp, err := client.GetImageGenerations(context.TODO(), azopenai.ImageGenerationOptions{
+		Prompt:         to.Ptr("a cat"),
+		ResponseFormat: to.Ptr(azopenai.ImageGenerationResponseFormatURL),
+		DeploymentName: &azureDeployment,
+	}, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	for _, generatedImage := range resp.Data {
+		// the underlying type for the generatedImage is dictated by the value of
+		// ImageGenerationOptions.ResponseFormat. In this example we used `azopenai.ImageGenerationResponseFormatURL`,
+		// so the underlying type will be ImageLocation.
+
+		resp, err := http.Head(*generatedImage.URL)
+
+		if err != nil {
+			// TODO: Update the following line with your application specific error handling logic
+			log.Printf("ERROR: %s", err)
+			return
+		}
+
+		_ = resp.Body.Close()
+		fmt.Fprintf(os.Stderr, "Image generated, HEAD request on URL returned %d\n", resp.StatusCode)
+	}
+
+}
+```
+
+
+## Completions (legacy)
+
+### Client.GetChatCompletions
+
+```go
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
+)
+
+func main() {
+	azureOpenAIKey := os.Getenv("AOAI_COMPLETIONS_API_KEY")
+	modelDeployment := os.Getenv("AOAI_COMPLETIONS_MODEL")
+
+	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
+	azureOpenAIEndpoint := os.Getenv("AOAI_COMPLETIONS_ENDPOINT")
+
+	if azureOpenAIKey == "" || modelDeployment == "" || azureOpenAIEndpoint == "" {
+		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
+		return
+	}
+
+	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)
+
+	// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
+	// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
+	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	resp, err := client.GetCompletions(context.TODO(), azopenai.CompletionsOptions{
+		Prompt:         []string{"What is Azure OpenAI, in 20 words or less"},
+		MaxTokens:      to.Ptr(int32(2048)),
+		Temperature:    to.Ptr(float32(0.0)),
+		DeploymentName: &modelDeployment,
+	}, nil)
+
+	if err != nil {
+		// TODO: Update the following line with your application specific error handling logic
+		log.Printf("ERROR: %s", err)
+		return
+	}
+
+	for _, choice := range resp.Choices {
+		fmt.Fprintf(os.Stderr, "Result: %s\n", *choice.Text)
+	}
+
+}
+```
+
+## Error handling
+
+All methods that send HTTP requests return `*azcore.ResponseError` when these requests fail. `ResponseError` has error details and the raw response from the service.
+
+### Logging
+
+This module uses the logging implementation in azcore. To turn on logging for all Azure SDK modules, set AZURE_SDK_GO_LOGGING to all. By default, the logger writes to stderr. Use the azcore/log package to control log output. For example, logging only HTTP request and response events, and printing them to stdout:
+
+```go
+import azlog "github.com/Azure/azure-sdk-for-go/sdk/azcore/log"
+
+// Print log events to stdout
+azlog.SetListener(func(cls azlog.Event, msg string) {
+	fmt.Println(msg)
+})
+
+// Includes only requests and responses in credential logs
+azlog.SetEvents(azlog.EventRequest, azlog.EventResponse)
+```
\ No newline at end of file