Merge pull request #4722 from RobiladK/patch-2

Update azure-functions-samples.md

Author: rmca14

articles/ai-services/agents/how-to/tools/azure-functions-samples.md

@@ -299,4 +299,244 @@ In the sample below we create a client and an agent that has the AI tools defini
 For any issues with the TypeScript code, create an issue on the [sample code repository](https://github.com/Azure-Samples/azure-functions-ai-services-agent-javascript/issues)
 
 
-::: zone-end
+::: zone-end
+
+::: zone pivot="csharp"
+
+## Using the .NET SDK
+
+### Prerequisites
+To make a function call, we need to create and deploy the Azure function. In the code snippet, we have an example of function on C# which can be used by the earlier code.
+
+```csharp
+    namespace FunctionProj
+    {
+        public class Response
+        {
+            public required string Value { get; set; }
+            public required string CorrelationId { get; set; }
+        }
+    
+        public class Arguments
+        {
+            public required string OutputQueueUri { get; set; }
+            public required string CorrelationId { get; set; }
+        }
+    
+        public class Foo
+        {
+            private readonly ILogger<Foo> _logger;
+    
+            public Foo(ILogger<Foo> logger)
+            {
+                _logger = logger;
+            }
+    
+            [Function("Foo")]
+            public void Run([QueueTrigger("azure-function-foo-input")] Arguments input, FunctionContext executionContext)
+            {
+                var logger = executionContext.GetLogger("Foo");
+                logger.LogInformation("C# Queue function processed a request.");
+    
+                // We have to provide the Managed identity for function resource
+                // and allow this identity a Queue Data Contributor role on the storage account.
+                var cred = new DefaultAzureCredential();
+                var queueClient = new QueueClient(new Uri(input.OutputQueueUri), cred,
+                        new QueueClientOptions { MessageEncoding = QueueMessageEncoding.Base64 });
+    
+                var response = new Response
+                {
+                    Value = "Bar",
+                    // Important! Correlation ID must match the input correlation ID.
+                    CorrelationId = input.CorrelationId
+                };
+    
+                var jsonResponse = JsonSerializer.Serialize(response);
+                queueClient.SendMessage(jsonResponse);
+            }
+        }
+    }
+```
+
+In this code we define function input and output class: `Arguments` and `Response` respectively. These two data classes are serialized in JSON. It's important that these both contain the `CorrelationId`, which is the same between input and output.
+
+In our example the function is stored in the storage account, created with the AI hub. For that we need to allow key access to that storage. In the Azure portal, go to Storage account > Settings > Configuration and set "Allow storage account key access" to Enabled. If it isn't done, the error that is displayed is "The remote server returned an error: (403) Forbidden." To create the function resource that will host our function, install azure-cli python package and run the next command:
+
+```shell
+    pip install -U azure-cli
+    az login
+    az functionapp create --resource-group your-resource-group --consumption-plan-location region --runtime dotnet-isolated --functions-version 4 --name function_name --storage-account storage_account_already_present_in_resource_group --app-insights existing_or_new_application_insights_name
+```
+
+This function writes data to the output queue and hence needs to be authenticated to Azure, so we'll need to assign the function system identity and provide it `Storage Queue Data Contributor`. To do that in Azure portal, select the function, located in `your-resource-group` resource group and in Settings > Identity, switch it on and select Save. After that assign the `Storage Queue Data Contributor` permission on storage account used by our function (`storage_account_already_present_in_resource_group` in the script above) for the assigned system managed identity.
+
+Now we'll create the function itself. Install [.NET](https://dotnet.microsoft.com/download) and [Core Tools](https://go.microsoft.com/fwlink/?linkid=2174087) and create the function project using next commands.
+
+```shell
+    func init FunctionProj --worker-runtime dotnet-isolated --target-framework net8.0
+    cd FunctionProj
+    func new --name foo --template "HTTP trigger" --authlevel "anonymous"
+    dotnet add package Azure.Identity
+    dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Storage.Queues --prerelease
+```
+
+> [!NOTE]
+> There's an "Azure Queue Storage trigger," however the attempt to use it results in error for now.
+We have created a project, containing HTTP-triggered Azure function with the logic in `Foo.cs` file. As far as we need to trigger Azure function by a new message in the queue, we replace the content of a Foo.cs by the C# sample code above.
+To deploy the function, run the command from dotnet project folder:
+
+```shell
+func azure functionapp publish function_name
+```
+
+In the `storage_account_already_present_in_resource_group` select the `Queue service` and create two queues: `azure-function-foo-input` and `azure-function-tool-output`. The same queues are used in our sample. To check that the function is working, place the next message into the `azure-function-foo-input` and replace `storage_account_already_present_in_resource_group` by the actual resource group name, or just copy the output queue address.
+
+```json
+    {
+      "OutputQueueUri": "https://storage_account_already_present_in_resource_group.queue.core.windows.net/azure-function-tool-output",
+      "CorrelationId": "42"
+    }
+```
+
+Next, we monitor the output queue or the message. You should receive the next message.
+
+```json
+    {
+      "Value": "Bar",
+      "CorrelationId": "42"
+    }
+```
+The input `CorrelationId` is the same as output.
+
+> [!TIP]
+> Place multiple messages to input queue and keep second internet browser window with the output queue open and hit the refresh button on the portal user interface, so that you won't miss the message. If the message instead went to `azure-function-foo-input-poison` queue, the function completed with error, check your setup.
+After testing the function and made sure it works, make sure that the Azure AI Project has the following roles for the storage account: `Storage Account Contributor`, `Storage Blob Data Contributor`, `Storage File Data Privileged Contributor`, `Storage Queue Data Contributor` and `Storage Table Data Contributor`. Now the function is ready to be used by the agent.
+
+In the example below we're calling function "foo," which responds "Bar."
+
+### .NET Sample Code
+
+1. First, we set up the necessary configuration, initialize the `PersistentAgentsClient`, define the `AzureFunctionToolDefinition` for our Azure Function, and then create the agent. This step includes all necessary `using` directives.
+
+    ```csharp
+    using Azure;
+    using Azure.AI.Agents.Persistent;
+    using Azure.Identity;
+    using Microsoft.Extensions.Configuration;
+    using System.Text.Json;
+
+    IConfigurationRoot configuration = new ConfigurationBuilder()
+        .SetBasePath(AppContext.BaseDirectory)
+        .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
+        .Build();
+
+    var projectEndpoint = configuration["ProjectEndpoint"];
+    var modelDeploymentName = configuration["ModelDeploymentName"];
+    var storageQueueUri = configuration["StorageQueueURI"];
+    PersistentAgentsClient client = new(projectEndpoint, new DefaultAzureCredential());
+
+    AzureFunctionToolDefinition azureFnTool = new(
+        name: "foo",
+        description: "Get answers from the foo bot.",
+        inputBinding: new AzureFunctionBinding(
+            new AzureFunctionStorageQueue(
+                queueName: "azure-function-foo-input",
+                storageServiceEndpoint: storageQueueUri
+            )
+        ),
+        outputBinding: new AzureFunctionBinding(
+            new AzureFunctionStorageQueue(
+                queueName: "azure-function-tool-output",
+                storageServiceEndpoint: storageQueueUri
+            )
+        ),
+        parameters: BinaryData.FromObjectAsJson(
+                new
+                {
+                    Type = "object",
+                    Properties = new
+                    {
+                        query = new
+                        {
+                            Type = "string",
+                            Description = "The question to ask.",
+                        },
+                        outputqueueuri = new
+                        {
+                            Type = "string",
+                            Description = "The full output queue uri."
+                        }
+                    },
+                },
+            new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }
+        )
+    );
+    
+    PersistentAgent agent = client.Administration.CreateAgent(
+        model: modelDeploymentName,
+        name: "azure-function-agent-foo",
+        instructions: "You are a helpful support agent. Use the provided function any "
+        + "time the prompt contains the string 'What would foo say?'. When you invoke "
+        + "the function, ALWAYS specify the output queue uri parameter as "
+        + $"'{storageQueueUri}/azure-function-tool-output'. Always responds with "
+        + "\"Foo says\" and then the response from the tool.",
+        tools: [azureFnTool]
+    );
+    ```
+
+2. Next, we create a new persistent agent thread and add an initial user message to it.
+
+   ```csharp
+    PersistentAgentThread thread = client.Threads.CreateThread();
+
+    client.Messages.CreateMessage(
+        thread.Id,
+        MessageRole.User,
+        "What is the most prevalent element in the universe? What would foo say?");
+    ```
+
+4. Then, we create a run for the agent on the thread and poll its status until it completes or requires action.
+
+    ```csharp
+    ThreadRun run = client.Runs.CreateRun(thread.Id, agent.Id);
+
+    do
+    {
+        Thread.Sleep(TimeSpan.FromMilliseconds(500));
+        run = client.Runs.GetRun(thread.Id, run.Id);
+    }
+    while (run.Status == RunStatus.Queued
+        || run.Status == RunStatus.InProgress
+        || run.Status == RunStatus.RequiresAction);
+    ```
+
+5. After the run is complete, we retrieve and process the messages from the thread.
+
+    ```csharp
+    Pageable<ThreadMessage> messages = client.Messages.GetMessages(
+        threadId: thread.Id,
+        order: ListSortOrder.Ascending
+    );
+
+    foreach (ThreadMessage threadMessage in messages)
+    {
+        foreach (MessageContent content in threadMessage.ContentItems)
+        {
+            switch (content)
+            {
+                case MessageTextContent textItem:
+                    Console.WriteLine($"[{threadMessage.Role}]: {textItem.Text}");
+                    break;
+            }
+        }
+    }
+    ```
+
+6. Finally, we clean up the created resources by deleting the thread and the agent.
+
+    ```csharp
+    client.Threads.DeleteThread(thread.Id);
+    client.Administration.DeleteAgent(agent.Id);
+    ```
+    
+::: zone-end

zone-pivots/zone-pivot-groups.yml

@@ -1153,6 +1153,8 @@ groups:
   title: Selections
   prompt: What would you like to see?
   pivots:
+  - id: csharp
+    title: C#
   - id: python
     title: Python
   - id: typescript
@@ -1228,4 +1230,4 @@ groups:
   - id: azure-portal
     title: Azure portal
   - id: cli
-    title: Azure CLI
+    title: Azure CLI