Dapr - Agent Integrations & .NET Aspire

dotnet new aiagent-webapi --help
AI Agent Web API (C#)
Author: Microsoft
Description: A project template for creating an AI Agent Web API application.
 
Usage:
  dotnet new aiagent-webapi [options] [template options]
 
Options:
  -n, --name <name>       The name for the output being created. If no name is specified, the name of the output directory is used.
  -o, --output <output>   Location to place the generated output.
  --dry-run               Displays a summary of what would happen if the given command line were run if it would result in a template creation. [default: False]
  --force                 Forces content to be generated even if it would change existing files. [default: False]
  --no-update-check       Disables checking for the template package updates when instantiating a template. [default: False]
  --project <project>     The project that should be used for context evaluation.
  -lang, --language <C#>  Specifies the template language to instantiate.
  --type <project>        Specifies the template type to instantiate.
 
Template options:
  -f, --framework <net10.0|net8.0|net9.0>              The target framework for the project.
                                                       Type: choice
                                                         net10.0  .NET 10
                                                         net9.0   .NET 9
                                                         net8.0   .NET 8
                                                       Default: net10.0
  --provider <azureopenai|githubmodels|ollama|openai>  Type: choice
                                                         azureopenai   Uses Azure OpenAI service
                                                         githubmodels  Uses GitHub Models
                                                         ollama        Uses Ollama with the llama3.2 model
                                                         openai        Uses the OpenAI Platform
                                                       Default: githubmodels
  --managed-identity                                   Use managed identity to access Azure services
                                                       Enabled if: (AiServiceProvider == "azureopenai")
                                                       Type: bool
                                                       Default: true
  --chat-model <chat-model>                            Model/deployment for chat completions. Example: gpt-4o-mini
                                                       Type: string

dotnet new aiagent-webapi -n AspireWithDapr.ApiService  

dotnet add package Diagrid.AI.Microsoft.AgentFramework --version 1.0.2

dotnet add package Swashbuckle.AspNetCore --version 10.1.5

// Program.cs
using System.ClientModel;
using System.ComponentModel;
using Diagrid.AI.Microsoft.AgentFramework.Abstractions;
using Diagrid.AI.Microsoft.AgentFramework.Hosting;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.DevUI;
using Microsoft.Agents.AI.Hosting;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;
using OpenAI;
using OpenAI.Chat;
 
var builder = WebApplication.CreateBuilder(args);
 
builder.AddServiceDefaults();
 
var chatClient = new ChatClient(
        "gpt-4o-mini",
        new ApiKeyCredential(builder.Configuration["GITHUB_TOKEN"] ?? throw new InvalidOperationException("Missing configuration: GITHUB_TOKEN")),
        new OpenAIClientOptions { Endpoint = new Uri("https://models.inference.ai.azure.com") })
    .AsIChatClient();
 
builder.Services.AddChatClient(chatClient);
 
builder.AddAIAgent("writer", "You write short stories (300 words or less) about the specified topic.");
 
builder.AddAIAgent("editor", (sp, key) => new ChatClientAgent(
    chatClient,
    name: key,
    instructions: "You edit short stories to improve grammar and style, ensuring the stories are less than 300 words. Once finished editing, you select a title and format the story for publishing.",
    tools: [AIFunctionFactory.Create(FormatStory)]
));
 
builder.AddWorkflow("publisher", (sp, key) => AgentWorkflowBuilder.BuildSequential(
    workflowName: key,
    agents:
    [
        sp.GetRequiredKeyedService<AIAgent>("writer"),
        sp.GetRequiredKeyedService<AIAgent>("editor")
    ]
)).AddAsAIAgent("publisher");
 
// Register the existing MAF agents with Diagrid 
builder.Services.AddDaprAgents()
    .WithAgent(sp => sp.GetRequiredKeyedService<AIAgent>("writer"))
    .WithAgent(sp => sp.GetRequiredKeyedService<AIAgent>("editor"))
    .WithAgent(sp => sp.GetRequiredKeyedService<AIAgent>("publisher"));
 
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
 
builder.Services.AddOpenAIResponses();
builder.Services.AddOpenAIConversations();
 
var app = builder.Build();
app.UseHttpsRedirection();
 
app.MapOpenAIResponses();
app.MapOpenAIConversations();
 
// Dapr Agent Invoker wraps agent invocation in a Durable workflow without explicit workflow needed.
app.MapPost("/agent/chat", async (IDaprAgentInvoker invoker, RunRequest request, CancellationToken cancellationToken) =>
{
    if (string.IsNullOrWhiteSpace(request.Prompt))
    {
        return Results.ValidationProblem(new Dictionary<string, string[]>
        {
            [nameof(request.Prompt)] = ["Prompt is required."]
        });
    }
 
    try
    {
        var agent = invoker.GetAgent(request.AgentName);
        var result = await invoker.RunAgentAsync(agent, request.Prompt, cancellationToken: cancellationToken);
        return Results.Ok(new { agent = request.AgentName, response = result.Text });
    }
    catch (InvalidOperationException)
    {
        return Results.BadRequest(new
        {
            error = $"Unknown agent '{request.AgentName}'.",
            availableAgents = new[] { "writer", "editor", "publisher" }
        });
    }
});
 
if (builder.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
    app.MapDevUI();
}
 
app.Run();
 
[Description("Formats the story for publication, revealing its title.")]
string FormatStory(string title, string story) => $"""
    **Title**: {title}
 
    {story}
    """;
sealed record RunRequest(string Prompt, string AgentName = "publisher");

dotnet add package CommunityToolkit.Aspire.Hosting.Dapr --version 13.0.0

// AppHpst.cs
using CommunityToolkit.Aspire.Hosting.Dapr;
 
var builder = DistributedApplication.CreateBuilder(args);
 
// Diagrid Dashboard for Dapr Agent & Worflow Visualization
var diagridDashboard = builder.AddContainer("diagrid-dashboard", "ghcr.io/diagridio/diagrid-dashboard", "latest")
    .WithHttpEndpoint(8080, 8080, name: "dashboard");
 
// Add RedisInsight GUI for Redis data visualization
var redisInsight = builder.AddContainer("redisinsight", "redislabs/redisinsight", "latest")
    .WithHttpEndpoint(8001, 8001)
    .WithEnvironment("RI_APP_PORT", "8001")
    .WithEnvironment("RI_HOST", "0.0.0.0")
    .WithBindMount(Path.Combine(builder.AppHostDirectory, "redisinsight-data"), "/data");
 
// Local State Store path
var stateStorePath = Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
    ".dapr",
    "components",
    "statestore.yaml");
 
if (!File.Exists(stateStorePath))
{
    throw new FileNotFoundException(
        "The default Dapr state store was not found. Run `dapr init` before starting the AppHost.",
        stateStorePath);
}
 
// Local State Store for Dapr
var stateStore = builder.AddDaprStateStore("statestore", new DaprComponentOptions
{
    LocalPath = stateStorePath
});
 
// Dapr API Service with sidecar configuration and reference to the state store
builder.AddProject<Projects.AspireWithDapr_ApiService>("apiservice")
    .WithDaprSidecar(sidecar =>
    {
        sidecar.WithOptions(new DaprSidecarOptions
        {
            AppId = "apiservice"
        });
        sidecar.WithReference(stateStore);
    })
    .WithExternalHttpEndpoints();
 
builder.Build().Run();

aspire run