{"id":2632,"date":"2025-10-23T17:40:31","date_gmt":"2025-10-23T17:40:31","guid":{"rendered":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2025\/10\/23\/upgrading-to-microsoft-agent-framework-in-your-net-ai-chat-app\/"},"modified":"2025-10-23T17:40:31","modified_gmt":"2025-10-23T17:40:31","slug":"upgrading-to-microsoft-agent-framework-in-your-net-ai-chat-app","status":"publish","type":"post","link":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2025\/10\/23\/upgrading-to-microsoft-agent-framework-in-your-net-ai-chat-app\/","title":{"rendered":"Upgrading to Microsoft Agent Framework in Your .NET AI Chat App"},"content":{"rendered":"

The AI App Templates let you spin up a working chat application in minutes, complete with AI integration, custom data ingestion, and all the pieces you need to get started. It\u2019s a cool and solid foundation.<\/p>\n

But here\u2019s the thing: what if you want to go beyond basic chat? What if you want to build AI agents that can actually reason<\/em>, make decisions, use tools, and orchestrate complex workflows? That\u2019s where Microsoft Agent Framework<\/strong> comes into play.<\/p>\n

In this post, I\u2019m going to show you how I took a standard AI chat app\u2014generated using the .NET AI templates\u2014and enhanced it with Microsoft Agent Framework. Let\u2019s start!<\/p>\n

What is Microsoft Agent Framework?<\/h2>\n

Microsoft Agent Framework<\/a> is Microsoft\u2019s preview framework for building AI agents in .NET. Think of it as the next evolution beyond simple chatbots. An AI agent can:<\/p>\n

Reason and plan<\/strong> through multi-step workflows
\nUse tools and functions<\/strong> to interact with your APIs, databases, and services
\nMaintain context<\/strong> across entire conversations
\nMake autonomous decisions<\/strong> based on instructions and data
\nCoordinate with other agents<\/strong> in multi-agent scenarios<\/p>\n

What I really like about it is that it\u2019s built on patterns we already know and love as .NET developers: dependency injection, middleware, telemetry\u2014all integrated with Microsoft.Extensions.AI. Check out Luis\u2019 great post about AgentFx<\/a> for all the details.<\/p>\n

Prerequisites<\/h2>\n

Before we start, you\u2019ll need:<\/p>\n

.NET 9 SDK<\/a> installed
\nVisual Studio<\/a> or Visual Studio Code<\/a> with C# Dev Kit
\nAn Azure account<\/a> with access to Azure OpenAI, or use it with GitHub Models<\/a>
\nThe .NET AI App Templates installed (we\u2019ll do this in the next section)
\nBasic familiarity with .NET, Blazor, and AI concepts<\/p>\n

Step 1: Creating the Base AI Chat Application<\/h2>\n

Let\u2019s start by creating a baseline chat app using the official .NET AI templates. First, we need to install the templates:<\/p>\n

dotnet new install Microsoft.Extensions.AI.Templates<\/p>\n

Creating the Project<\/h3>\n

Now let\u2019s create the app. You can do this through Visual Studio or the CLI:<\/p>\n

Using Visual Studio:<\/strong><\/p>\n

Open Visual Studio 2022
\nSelect Create a new project<\/strong>
\nSearch for \u201cAI Chat Web App\u201d
\nConfigure your project name (e.g., ChatApp20) and location
\nSelect Azure OpenAI<\/strong> as your AI provider
\nChoose Local on-disk<\/strong> for the vector store
\nChoose .NET Aspire for the orchestration<\/p>\n

Using Visual Studio Code or the .NET CLI:<\/strong><\/p>\n

If you prefer VS Code or the command line, check out the official documentation<\/a> for step-by-step instructions. The process is similar\u2014you\u2019ll use dotnet new commands to scaffold the project with the same configuration options.<\/p>\n

Understanding the Project Structure<\/h3>\n

The template generates a solution with three projects:<\/p>\n

ChatApp20\/
\n\u251c\u2500\u2500 ChatApp20.Web\/ # Blazor Server app with chat UI
\n\u251c\u2500\u2500 ChatApp20.AppHost\/ # .NET Aspire orchestration
\n\u2514\u2500\u2500 ChatApp20.ServiceDefaults\/ # Shared service configurations<\/p>\n

We\u2019ll be working mainly in ChatApp20.Web, which includes:<\/p>\n

Components\/Pages\/Chat\/<\/strong> \u2013 The Blazor chat interface
\nServices\/<\/strong> \u2013 Data ingestion and semantic search services
\nProgram.cs<\/strong> \u2013 Where all the AI magic gets wired up
\nwwwroot\/Data\/<\/strong> \u2013 Sample PDF files (survival kit and GPS watch examples)<\/p>\n

Initial Program.cs Configuration<\/h3>\n

Let\u2019s look at what the template sets up for us in Program.cs. This is where all the AI pieces come together:<\/p>\n

using Microsoft.Extensions.AI;
\nusing ChatApp20.Web.Components;
\nusing ChatApp20.Web.Services;
\nusing ChatApp20.Web.Services.Ingestion;<\/p>\n

var builder = WebApplication.CreateBuilder(args);
\nbuilder.AddServiceDefaults();
\nbuilder.Services.AddRazorComponents().AddInteractiveServerComponents();<\/p>\n

\/\/ Configure Azure OpenAI with chat client and embeddings
\nvar openai = builder.AddAzureOpenAIClient(“openai”);
\nopenai.AddChatClient(“gpt-4o-mini”)
\n .UseFunctionInvocation()
\n .UseOpenTelemetry(configure: c =>
\n c.EnableSensitiveData = builder.Environment.IsDevelopment());
\nopenai.AddEmbeddingGenerator(“text-embedding-3-small”);<\/p>\n

\/\/ Configure vector storage for semantic search
\nvar vectorStorePath = Path.Combine(AppContext.BaseDirectory, “vector-store.db”);
\nvar vectorStoreConnectionString = $”Data Source={vectorStorePath}”;
\nbuilder.Services.AddSqliteCollection<string, IngestedChunk>(“data-chatapp20-chunks”, vectorStoreConnectionString);
\nbuilder.Services.AddSqliteCollection<string, IngestedDocument>(“data-chatapp20-documents”, vectorStoreConnectionString);
\nbuilder.Services.AddScoped<DataIngestor>();
\nbuilder.Services.AddSingleton<SemanticSearch>();<\/p>\n

var app = builder.Build();<\/p>\n

\/\/ … middleware configuration …<\/p>\n

\/\/ Ingest PDF files on startup
\nawait DataIngestor.IngestDataAsync(
\n app.Services,
\n new PDFDirectorySource(Path.Combine(builder.Environment.WebRootPath, “Data”)));<\/p>\n

app.Run();<\/p>\n

The Basic Chat Component<\/h3>\n

The initial Chat.razor component uses IChatClient directly:<\/p>\n

@inject IChatClient ChatClient
\n@inject SemanticSearch Search<\/p>\n

@code {
\n private async Task AddUserMessageAsync(ChatMessage userMessage)
\n {
\n messages.Add(userMessage);<\/p>\n

var responseText = new TextContent(“”);
\n currentResponseMessage = new ChatMessage(ChatRole.Assistant, [responseText]);<\/p>\n

await foreach (var update in ChatClient.GetStreamingResponseAsync(
\n messages.Skip(statefulMessageCount),
\n chatOptions,
\n currentResponseCancellation.Token))
\n {
\n messages.AddMessages(update, filter: c => c is not TextContent);
\n responseText.Text += update.Text;
\n ChatMessageItem.NotifyChanged(currentResponseMessage);
\n }<\/p>\n

messages.Add(currentResponseMessage);
\n }<\/p>\n

[Description(“Searches for information using a phrase or keyword”)]
\n private async Task<IEnumerable<string>> SearchAsync(
\n [Description(“The phrase to search for.”)] string searchPhrase,
\n [Description(“If possible, specify the filename to search.”)] string? filenameFilter = null)
\n {
\n var results = await Search.SearchAsync(searchPhrase, filenameFilter, maxResults: 5);
\n return results.Select(result =>
\n $”<result filename=”{result.DocumentId}” page_number=”{result.PageNumber}”>{result.Text}<\/result>”);
\n }
\n}<\/p>\n

This works great for getting started! But as your app grows, you\u2019ll want more flexibility:<\/p>\n

Better separation of concerns<\/strong> \u2013 Moving tool functions out of UI components
\nEasier testing<\/strong> \u2013 Testing agent behavior independently from the UI
\nMore sophisticated patterns<\/strong> \u2013 Support for complex reasoning and multi-step workflows
\nAgent orchestration<\/strong> \u2013 Coordinating multiple specialized agents
\nRicher telemetry<\/strong> \u2013 Better observability into how your AI makes decisions<\/p>\n

That\u2019s exactly what Microsoft Agent Framework brings to the table. Let\u2019s see how!<\/p>\n

Step 2: Adding Microsoft Agent Framework<\/h2>\n

Now for the fun part\u2014let\u2019s upgrade this chat app into a proper agent system!<\/p>\n

Installing the Required Packages<\/h3>\n

First, we need to add the Microsoft Agent Framework packages to ChatApp20.Web.csproj:<\/p>\n\n

<ItemGroup>
\n <!– Keep existing packages –>
\n <PackageReference Include=”Aspire.Azure.AI.OpenAI” Version=”9.5.1-preview.1.25502.11″ \/>
\n <PackageReference Include=”Microsoft.Extensions.AI.OpenAI” Version=”9.10.0-preview.1.25513.3″ \/>
\n <PackageReference Include=”Microsoft.Extensions.AI” Version=”9.10.0″ \/>
\n <PackageReference Include=”Microsoft.SemanticKernel.Core” Version=”1.66.0″ \/><\/p>\n

<!– Add Microsoft Agent Framework packages –>
\n <PackageReference Include=”Microsoft.Agents.AI” Version=”1.0.0-preview.251009.1″ \/>
\n <PackageReference Include=”Microsoft.Agents.AI.Abstractions” Version=”1.0.0-preview.251009.1″ \/>
\n <PackageReference Include=”Microsoft.Agents.AI.Hosting” Version=”1.0.0-preview.251009.1″ \/>
\n <PackageReference Include=”Microsoft.Agents.AI.Hosting.OpenAI” Version=”1.0.0-alpha.251009.1″ \/>
\n <PackageReference Include=”Microsoft.Agents.AI.OpenAI” Version=”1.0.0-preview.251009.1″ \/><\/p>\n

<!– Keep other existing packages –>
\n <PackageReference Include=”PdfPig” Version=”0.1.12-alpha-20251015-255e7″ \/>
\n <PackageReference Include=”System.Linq.Async” Version=”7.0.0-preview.1.g24680b5469″ \/>
\n <PackageReference Include=”Microsoft.SemanticKernel.Connectors.SqliteVec” Version=”1.66.0-preview” \/>
\n<\/ItemGroup><\/p>\n

The key Agent Framework packages are:<\/p>\n

Microsoft.Agents.AI<\/strong> \u2013 Core agent abstractions and implementations
\nMicrosoft.Agents.AI.Abstractions<\/strong> \u2013 Base interfaces and types
\nMicrosoft.Agents.AI.Hosting<\/strong> \u2013 Dependency injection and hosting extensions
\nMicrosoft.Agents.AI.Hosting.OpenAI<\/strong> \u2013 OpenAI-specific hosting support
\nMicrosoft.Agents.AI.OpenAI<\/strong> \u2013 OpenAI integration for agents<\/p>\n

Creating a Dedicated Search Functions Service<\/h3>\n

To promote better separation of concerns and testability, create a new SearchFunctions.cs service that wraps the semantic search functionality:<\/p>\n

using System.ComponentModel;<\/p>\n

namespace ChatApp20.Web.Services;<\/p>\n

\/\/\/ <summary>
\n\/\/\/ Functions exposed to the AI Agent. Wraps SemanticSearch so we can inject dependencies via DI.
\n\/\/\/ <\/summary>
\npublic class SearchFunctions
\n{
\n private readonly SemanticSearch _semanticSearch;<\/p>\n

public SearchFunctions(SemanticSearch semanticSearch)
\n {
\n _semanticSearch = semanticSearch;
\n }<\/p>\n

[Description(“Searches for information using a phrase or keyword”)]
\n public async Task<IEnumerable<string>> SearchAsync(
\n [Description(“The phrase to search for.”)] string searchPhrase,
\n [Description(“If possible, specify the filename to search that file only. If not provided or empty, the search includes all files.”)] string? filenameFilter = null)
\n {
\n \/\/ Perform semantic search over ingested chunks
\n var results = await _semanticSearch.SearchAsync(searchPhrase, filenameFilter, maxResults: 5);<\/p>\n

\/\/ Format results as XML for the agent
\n return results.Select(result =>
\n $”<result filename=”{result.DocumentId}” page_number=”{result.PageNumber}”>{result.Text}<\/result>”);
\n }
\n}<\/p>\n

Why this is important:<\/strong><\/p>\n

The SearchFunctions class is now a dedicated service that can be injected into the agent
\nIt\u2019s testable in isolation from the UI
\nThe [Description] attributes provide metadata that helps the AI understand when and how to use the tool
\nThe agent can invoke this function automatically when it needs to search for information<\/p>\n

Registering the AI Agent in Program.cs<\/h3>\n

Now, let\u2019s configure the AI agent in Program.cs using the Agent Framework\u2019s hosting extensions:<\/p>\n

using ChatApp20.Web.Components;
\nusing ChatApp20.Web.Services;
\nusing ChatApp20.Web.Services.Ingestion;
\nusing Microsoft.Agents.AI;
\nusing Microsoft.Agents.AI.Hosting;
\nusing Microsoft.Extensions.AI;
\nusing System.ComponentModel;<\/p>\n

var builder = WebApplication.CreateBuilder(args);
\nbuilder.AddServiceDefaults();
\nbuilder.Services.AddRazorComponents().AddInteractiveServerComponents();<\/p>\n

\/\/ Configure Azure OpenAI
\nvar openai = builder.AddAzureOpenAIClient(“openai”);
\nopenai.AddChatClient(“gpt-4o-mini”)
\n .UseFunctionInvocation()
\n .UseOpenTelemetry(configure: c =>
\n c.EnableSensitiveData = builder.Environment.IsDevelopment());<\/p>\n

\/\/ Register the AI Agent using the Agent Framework
\nbuilder.AddAIAgent(“ChatAgent”, (sp, key) =>
\n{
\n \/\/ Get required services
\n var logger = sp.GetRequiredService<ILogger<Program>>();
\n logger.LogInformation(“Configuring AI Agent with key ‘{Key}’ for model ‘{Model}'”, key, “gpt-4o-mini”);<\/p>\n

var searchFunctions = sp.GetRequiredService<SearchFunctions>();
\n var chatClient = sp.GetRequiredService<IChatClient>();<\/p>\n

\/\/ Create and configure the AI agent
\n var aiAgent = chatClient.CreateAIAgent(
\n name: key,
\n instructions: “You are a useful agent that helps users with short and funny answers.”,
\n description: “An AI agent that helps users with short and funny answers.”,
\n tools: [AIFunctionFactory.Create(searchFunctions.SearchAsync)]
\n )
\n .AsBuilder()
\n .UseOpenTelemetry(configure: c =>
\n c.EnableSensitiveData = builder.Environment.IsDevelopment())
\n .Build();<\/p>\n

return aiAgent;
\n});<\/p>\n

\/\/ Configure embeddings and vector storage
\nopenai.AddEmbeddingGenerator(“text-embedding-3-small”);<\/p>\n

var vectorStorePath = Path.Combine(AppContext.BaseDirectory, “vector-store.db”);
\nvar vectorStoreConnectionString = $”Data Source={vectorStorePath}”;
\nbuilder.Services.AddSqliteCollection<string, IngestedChunk>(“data-chatapp20-chunks”, vectorStoreConnectionString);
\nbuilder.Services.AddSqliteCollection<string, IngestedDocument>(“data-chatapp20-documents”, vectorStoreConnectionString);
\nbuilder.Services.AddScoped<DataIngestor>();
\nbuilder.Services.AddSingleton<SemanticSearch>();<\/p>\n

\/\/ Register SearchFunctions for DI injection into the agent
\nbuilder.Services.AddSingleton<SearchFunctions>();<\/p>\n

var app = builder.Build();<\/p>\n

\/\/ … rest of the configuration …<\/p>\n

Key points about the agent registration:<\/strong><\/p>\n

Keyed Service Registration<\/strong>: The agent is registered with the key “ChatAgent” using builder.AddAIAgent(). This allows you to register multiple agents in the same application.
\nAgent Configuration<\/strong>: The agent is created with:<\/p>\n

A name<\/strong> for identification
\nInstructions<\/strong> (system prompt) that define its personality and behavior
\nA description<\/strong> that explains its purpose
\nTools<\/strong> that the agent can use (in this case, the SearchAsync function)<\/p>\n

Tool Binding<\/strong>: The AIFunctionFactory.Create() method converts the SearchAsync method into a tool that the agent can invoke. The framework automatically handles:<\/p>\n

Parameter validation based on the [Description] attributes
\nJSON serialization\/deserialization
\nError handling and retries<\/p>\n

Telemetry<\/strong>: The UseOpenTelemetry() call ensures that all agent interactions are logged and can be observed through Application Insights or other monitoring tools.
\nDependency Injection<\/strong>: The agent factory receives an IServiceProvider, allowing it to resolve dependencies like SearchFunctions and IChatClient.<\/p>\n

Updating the Chat Component<\/h3>\n

Finally, we need to update Chat.razor to use our new AI agent. The changes are pretty straightforward:<\/p>\n

Key changes in the code-behind:<\/strong><\/p>\n

Inject the IServiceProvider<\/strong> instead of IChatClient:<\/p>\n

@inject IServiceProvider ServiceProvider
\n@using Microsoft.Agents.AI<\/p>\n

Resolve the agent<\/strong> in OnInitialized():<\/p>\n

private AIAgent aiAgent = default!;<\/p>\n

protected override void OnInitialized()
\n{
\n \/\/ Resolve the keyed AI agent registered as “ChatAgent” in Program.cs
\n aiAgent = ServiceProvider.GetRequiredKeyedService<AIAgent>(“ChatAgent”);
\n \/\/ … rest of initialization …
\n}<\/p>\n

Use agent streaming<\/strong> in AddUserMessageAsync():<\/p>\n

\/\/ Replace ChatClient.GetStreamingResponseAsync with agent streaming
\nawait foreach (var update in aiAgent.RunStreamingAsync(
\n messages: messages.Skip(statefulMessageCount),
\n cancellationToken: currentResponseCancellation.Token))
\n{
\n var responseUpdate = update.AsChatResponseUpdate();
\n messages.AddMessages(responseUpdate, filter: c => c is not TextContent);
\n responseText.Text += update.Text;
\n chatOptions.ConversationId = responseUpdate.ConversationId;
\n ChatMessageItem.NotifyChanged(currentResponseMessage);
\n}<\/p>\n

That\u2019s it! The agent handles everything else\u2014tool invocation, reasoning, and response generation.<\/p>\n

Step 3: Running and Testing the Enhanced Application<\/h2>\n

Running with .NET Aspire<\/h3>\n

One of the best parts about using the AI templates is that everything runs through .NET Aspire. This gives you:<\/p>\n

Service discovery<\/strong> between components
\nUnified logging<\/strong> and telemetry in the Aspire dashboard
\nHealth checks<\/strong> for all services
\nEasy configuration<\/strong> for all your secrets and settings<\/p>\n

Run the app. The Aspire dashboard opens automatically in your browser<\/p>\n\n

Configuring Azure OpenAI<\/h3>\n

On first run, you\u2019ll be prompted to configure Azure OpenAI:<\/p>\n

Azure Subscription<\/strong>: Select your subscription
\nResource Group<\/strong>: Choose existing or create new
\nAzure OpenAI Resource<\/strong>: Select or provision
\nModel Deployments<\/strong>: Ensure you have:<\/p>\n

A chat model (e.g., gpt-4o-mini)
\nAn embedding model (e.g., text-embedding-3-small)<\/p>\n

The configuration will be saved locally and reused for subsequent runs.<\/p>\n

Testing the Agent<\/h3>\n

Once everything is running, click on the web endpoint in the Aspire dashboard (usually https:\/\/localhost:7001).<\/p>\n\n

Let\u2019s test it out:<\/p>\n

Basic conversation:<\/strong>
\nYou: Hello! How are you?
\nAgent: Hey! I’m great \u2014 fully charged, like an Emergency Survival Kit.<\/p>\n

Tool invocation with semantic search:<\/strong>
\nYou: What should I include in an emergency survival kit?
\nAgent: Short survival-kit checklist (funny edition) First aid supplies \u2014 bandages, gauze, antiseptics.
\n <citation filename=’Example_Emergency_Survival_Kit.pdf’ page_number=’1′>water and food supplies<\/citation><\/p>\n

File-specific queries:<\/strong>
\nYou: Tell me about the GPS watch features
\nAgent: The GPS watch includes…
\n <citation filename=’Example_GPS_Watch.pdf’ page_number=’2′>real-time tracking<\/citation><\/p>\n

Here\u2019s the cool part: check out the Aspire dashboard while the agent is working. You can actually see:<\/p>\n

When the agent decides to invoke the search tool
\nWhat parameters it passes
\nThe search results it gets back
\nHow it synthesizes everything into a response<\/p>\n


\nhttps:\/\/devblogs.microsoft.com\/dotnet\/wp-content\/uploads\/sites\/10\/2025\/10\/07-image-telemetry.webm<\/a><\/div>\n

This level of observability is invaluable when you\u2019re debugging or optimizing your agent\u2019s behavior.<\/p>\n

Advanced Scenarios<\/h2>\n

Adding More Tools to Your Agent<\/h3>\n

You can easily extend your agent with additional capabilities:<\/p>\n

public class WeatherFunctions
\n{
\n [Description(“Gets the current weather for a location”)]
\n public async Task<string> GetWeatherAsync(
\n [Description(“The city and state\/country”)] string location)
\n {
\n \/\/ Call weather API
\n return $”Weather for {location}: Sunny, 72\u00b0F”;
\n }
\n}<\/p>\n

\/\/ In Program.cs
\nbuilder.Services.AddSingleton<WeatherFunctions>();<\/p>\n

builder.AddAIAgent(“ChatAgent”, (sp, key) =>
\n{
\n var searchFunctions = sp.GetRequiredService<SearchFunctions>();
\n var weatherFunctions = sp.GetRequiredService<WeatherFunctions>();
\n var chatClient = sp.GetRequiredService<IChatClient>();<\/p>\n

return chatClient.CreateAIAgent(
\n name: key,
\n instructions: “You can search documents and check weather…”,
\n tools: [
\n AIFunctionFactory.Create(searchFunctions.SearchAsync),
\n AIFunctionFactory.Create(weatherFunctions.GetWeatherAsync)
\n ]
\n ).Build();
\n});<\/p>\n

\n

Note<\/strong><\/p>\n

You can check out the full running sample in Generative AI for Beginners \u2013 .NET<\/a>.<\/p><\/div>\n

Multi-Agent Scenarios<\/h3>\n

The Agent Framework makes it easy to coordinate multiple specialized agents:<\/p>\n

\/\/ Register a research agent
\nbuilder.AddAIAgent(“ResearchAgent”, (sp, key) =>
\n{
\n var chatClient = sp.GetRequiredService<IChatClient>();
\n var searchFunctions = sp.GetRequiredService<SearchFunctions>();<\/p>\n

return chatClient.CreateAIAgent(
\n name: “ResearchAgent”,
\n instructions: “You are a research specialist. Find and summarize information from documents.”,
\n tools: [AIFunctionFactory.Create(searchFunctions.SearchAsync)]
\n ).Build();
\n});<\/p>\n

\/\/ Register a writing agent
\nbuilder.AddAIAgent(“WritingAgent”, (sp, key) =>
\n{
\n var chatClient = sp.GetRequiredService<IChatClient>();<\/p>\n

return chatClient.CreateAIAgent(
\n name: “WritingAgent”,
\n instructions: “You are a writing specialist. Take information and create well-structured, engaging content.”,
\n tools: []
\n ).Build();
\n});<\/p>\n

\/\/ Register a coordinator agent that uses both
\nbuilder.AddAIAgent(“CoordinatorAgent”, (sp, key) =>
\n{
\n var chatClient = sp.GetRequiredService<IChatClient>();
\n var researchAgent = sp.GetRequiredKeyedService<AIAgent>(“ResearchAgent”);
\n var writingAgent = sp.GetRequiredKeyedService<AIAgent>(“WritingAgent”);<\/p>\n

\/\/ Create functions that delegate to other agents
\n async Task<string> ResearchAsync(string topic)
\n {
\n var messages = new[] { new ChatMessage(ChatRole.User, topic) };
\n var result = await researchAgent.RunAsync(messages);
\n return result.Text ?? “”;
\n }<\/p>\n

async Task<string> WriteAsync(string content)
\n {
\n var messages = new[] { new ChatMessage(ChatRole.User, $”Write an article based on: {content}”) };
\n var result = await writingAgent.RunAsync(messages);
\n return result.Text ?? “”;
\n }<\/p>\n

return chatClient.CreateAIAgent(
\n name: “CoordinatorAgent”,
\n instructions: “Coordinate research and writing to create comprehensive articles.”,
\n tools: [
\n AIFunctionFactory.Create(ResearchAsync),
\n AIFunctionFactory.Create(WriteAsync)
\n ]
\n ).Build();
\n});<\/p>\n

\n

Note<\/strong><\/p>\n

For more examples of multi-agent coordination patterns, check out the Generative AI for Beginners \u2013 .NET<\/a>.<\/p><\/div>\n

Custom Agent Middleware<\/h3>\n

You can add custom middleware to agents for logging, caching, or custom behavior:<\/p>\n

builder.AddAIAgent(“ChatAgent”, (sp, key) =>
\n{
\n var chatClient = sp.GetRequiredService<IChatClient>();
\n var searchFunctions = sp.GetRequiredService<SearchFunctions>();
\n var logger = sp.GetRequiredService<ILogger<Program>>();<\/p>\n

return chatClient.CreateAIAgent(
\n name: key,
\n instructions: “…”,
\n tools: [AIFunctionFactory.Create(searchFunctions.SearchAsync)]
\n )
\n .AsBuilder()
\n .Use(async (messages, options, next, cancellationToken) =>
\n {
\n \/\/ Custom pre-processing
\n logger.LogInformation(“Agent processing {MessageCount} messages”, messages.Count());<\/p>\n

\/\/ Call next in pipeline
\n var result = await next(messages, options, cancellationToken);<\/p>\n

\/\/ Custom post-processing
\n logger.LogInformation(“Agent generated response with {ContentCount} content items”, result.Contents.Count);<\/p>\n

return result;
\n })
\n .UseOpenTelemetry(configure: c => c.EnableSensitiveData = true)
\n .Build();
\n});<\/p>\n

\n

Note<\/strong><\/p>\n

You can find more examples of custom middleware patterns in the Generative AI for Beginners \u2013 .NET<\/a>.<\/p><\/div>\n

Best Practices<\/h2>\n

1. Design Clear Tool Descriptions<\/h3>\n

The quality of your agent\u2019s tool invocations depends heavily on good descriptions:<\/p>\n

[Description(“Searches for specific information in product documentation. ” +
\n “Use this when the user asks about features, specifications, or how to use products. ” +
\n “Returns relevant excerpts with filename and page numbers for citations.”)]
\npublic async Task<IEnumerable<string>> SearchAsync(
\n [Description(“The specific phrase, keyword, or question to search for. ” +
\n “Be specific and include relevant context.”)]
\n string searchPhrase,
\n [Description(“Optional: The exact filename to search within (e.g., ‘ProductManual.pdf’). ” +
\n “Leave empty to search all documents.”)]
\n string? filenameFilter = null)
\n{
\n \/\/ Implementation
\n}<\/p>\n

2. Test Agent Behavior<\/h3>\n

Create unit tests for your agent tools and integration tests for agent workflows:<\/p>\n

public class SearchFunctionsTests
\n{
\n [Fact]
\n public async Task SearchAsync_WithValidQuery_ReturnsResults()
\n {
\n \/\/ Arrange
\n var mockSemanticSearch = new Mock<SemanticSearch>();
\n mockSemanticSearch
\n .Setup(s => s.SearchAsync(“test”, null, 5))
\n .ReturnsAsync(new List<IngestedChunk>
\n {
\n new IngestedChunk { DocumentId = “test.pdf”, PageNumber = 1, Text = “test content” }
\n });<\/p>\n

var searchFunctions = new SearchFunctions(mockSemanticSearch.Object);<\/p>\n

\/\/ Act
\n var results = await searchFunctions.SearchAsync(“test”);<\/p>\n

\/\/ Assert
\n Assert.NotEmpty(results);
\n Assert.Contains(“test content”, results.First());
\n }
\n}<\/p>\n

3. Monitor Agent Performance<\/h3>\n

Use Application Insights or .NET Aspire\u2019s dashboard to monitor:<\/p>\n

Token usage<\/strong> per agent interaction
\nTool invocation patterns<\/strong> (which tools are used, how often)
\nResponse times<\/strong> for agent operations
\nError rates<\/strong> for tool calls
\nUser satisfaction<\/strong> through feedback mechanisms<\/p>\n

Performance Considerations<\/h2>\n

Streaming vs. Non-Streaming<\/h3>\n

The Agent Framework supports both streaming and non-streaming responses:<\/p>\n

Use streaming when:<\/strong><\/p>\n

Building interactive chat interfaces
\nUsers expect real-time feedback
\nProcessing long-running queries<\/p>\n

Use non-streaming when:<\/strong><\/p>\n

Processing in the background
\nBatch operations
\nSimple API endpoints<\/p>\n

Tool Call Optimization<\/h3>\n

Minimize unnecessary tool calls:<\/p>\n

\/\/ Good: Specific instructions
\n“Use the search tool only when the user asks a specific question about the documents.
\nDon’t search if you can answer from general knowledge.”<\/p>\n

\/\/ Bad: Vague instructions
\n“You have access to a search tool.”<\/p>\n

Deployment to Azure<\/h2>\n

The application is ready for deployment to Azure using .NET Aspire\u2019s Azure provisioning:<\/p>\n

# Login to Azure
\naz login<\/p>\n

# Create Azure resources
\ncd ChatApp20.AppHost
\nazd init
\nazd up<\/p>\n

This will:<\/p>\n

Provision Azure OpenAI resources
\nDeploy the web application to Azure Container Apps
\nSet up Application Insights for monitoring
\nConfigure service connections and authentication<\/p>\n

For detailed deployment instructions, see the .NET Aspire Azure deployment documentation<\/a>.<\/p>\n

Summary<\/h2>\n

And there you have it! We\u2019ve taken a standard AI chat app and transformed it into a proper agent system using Microsoft Agent Framework. The upgrade gives you better architecture with clean separation of concerns, easier testing, and built-in observability\u2014all while using the .NET patterns you already know.<\/p>\n

What I really appreciate is that Microsoft Agent Framework doesn\u2019t force you to learn a completely new way of doing things. It builds on familiar concepts like dependency injection, middleware, and telemetry, making it feel natural for C# developers.<\/p>\n

If you\u2019re building AI applications with .NET, I highly recommend giving the Agent Framework a try. Start with the AI templates<\/a>, then layer on the agent capabilities as your needs grow. Check out the official documentation<\/a> and Luis\u2019 announcement post<\/a> to learn more!<\/p>\n

The post Upgrading to Microsoft Agent Framework in Your .NET AI Chat App<\/a> appeared first on .NET Blog<\/a>.<\/p>","protected":false},"excerpt":{"rendered":"

The AI App Templates let you spin up a working chat application in minutes, complete with AI integration, custom data […]<\/p>\n","protected":false},"author":0,"featured_media":0,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[7],"tags":[],"class_list":["post-2632","post","type-post","status-publish","format-standard","hentry","category-dotnet"],"_links":{"self":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/2632","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/comments?post=2632"}],"version-history":[{"count":0,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/2632\/revisions"}],"wp:attachment":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/media?parent=2632"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/categories?post=2632"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/tags?post=2632"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}