用 C# + Blazor 开发智能体教程：从工具调用到流式对话

适用人群：熟悉 C# / ASP.NET Core，想做出「能真正干活」的 AI 应用的开发者。
技术栈：.NET 10（.NET 9 亦可）+ Blazor Web App（Interactive Server）+ Microsoft.Extensions.AI。
最终成果：一个可以在浏览器里对话、会自己调用工具（查订单、算数、看时间）并流式输出推理过程的智能体。

1. 先搞清楚：智能体不是「聊天框」

很多人把「接了 OpenAI 的聊天页面」叫智能体，其实那只完成了 20%。真正的智能体 = 模型 + 工具 + 循环 + 状态。

核心循环长这样：

          ┌────────────────────────────────────────────┐
          │                                            │
用户提问 ──► LLM 推理 ──► 输出「文字 + 工具调用请求」──┐   │
                          │                          │   │
                          ├─ 没有工具调用 → 直接回答 ──┘   │
                          │                              │
                          └─ 有工具调用 → 执行工具 ────────┘
                                          │
                                    结果回填给 LLM
                                    （下一轮推理）

记住这句话：智能体的「智能」来自模型，但「干活能力」来自你的代码。 大模型只负责决策，真正查询订单、写数据库、发邮件的是你注册的工具方法。这也是为什么 C# 后端开发者做智能体有天然优势——你的业务代码本来就是工具。

2. 技术选型：Blazor 三种模式与模型接入层

2.1 Blazor 三种托管模式怎么选

结论：智能体应用一律先用 Interactive Server。 原因有三个：

1. API Key 永远留在服务器，不会被打包进浏览器；
2. 流式输出直接走服务端，不受浏览器 CORS 限制；
3. 工具可能读写数据库，天然应该在后端执行。

如果确实要做纯前端，也必须搭一个自己的 BFF（Backend for Frontend）中转，不要在 WASM 里直连模型。

2.2 模型接入层：三选一

Microsoft.Extensions.AI 的核心对象只有四个，先混个脸熟：

3. 环境准备

# 1) 检查 SDK（需要 .NET 9 或 10）
dotnet --list-sdks

# 2) 准备一个模型 API Key（OpenAI / Azure OpenAI / DeepSeek / 通义 / 本地 Ollama 均可）
#    本教程所有示例都走「OpenAI 兼容协议」，大多数厂商都支持

还需要：

• 编辑器：Visual Studio 2026（或 2022 17.12+）/ VS Code + C# Dev Kit；
• 一个能跑通 https://api.openai.com/v1/chat/completions 的 Key。

本地模型也可以：装好 Ollama 后执行 ollama pull qwen2.5:14b，接口地址用 http://localhost:11434/v1。注意 7B 以下的模型工具调用经常不稳定，做工具类智能体建议至少 14B。

4. 创建项目

dotnet new blazor -n AgentStudio -int Server
cd AgentStudio

dotnet add package Microsoft.Extensions.AI
dotnet add package Microsoft.Extensions.AI.OpenAI

Microsoft.Extensions.AI 若还是预览版，加 --prerelease。

生成的目录先删掉模板自带的 Counter、Weather 示例（可选），然后按下表新增文件：

AgentStudio/
├── Program.cs                     ← 注册服务、配置模型
├── appsettings.json               ← 非机密配置
├── Models/
│   └── AgentChunk.cs              ← 流式输出的数据块
├── Services/
│   ├── OrderRepository.cs         ← 模拟业务数据（换成你的 DbContext 即可）
│   ├── AgentTools.cs              ← 工具集合
│   └── AgentService.cs            ← 智能体主循环
├── Components/
│   ├── App.razor
│   ├── Routes.razor
│   ├── Layout/
│   │   └── NavMenu.razor          ← 加一个「智能体」菜单项
│   └── Pages/
│       └── Chat.razor             ← 对话页面
└── wwwroot/
    └── app.css                    ← 追加聊天样式

5. 配置模型接入

5.1 配置文件（不含密钥）

appsettings.json：

{
  "AI": {
    "Endpoint": "https://api.openai.com/v1",
    "ModelId": "gpt-4o-mini",
    "MaxIterations": 6,
    "TimeoutSeconds": 180
  }
}

密钥走 user-secrets，绝不进代码库（SVN 也要加 ignore）：

dotnet user-secrets init
dotnet user-secrets set "AI:ApiKey" "sk-你的真实密钥"

不同厂商的配置对照：

5.2 Program.cs

using AgentStudio.Services;
using Microsoft.Extensions.AI;
using OpenAI;
using System.ClientModel;

var builder = WebApplication.CreateBuilder(args);

// Blazor 交互式服务端
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

// ---- 模型客户端（OpenAI 兼容协议）----
var aiSection = builder.Configuration.GetSection("AI");
var apiKey = aiSection["ApiKey"]
    ?? throw new InvalidOperationException("缺少 AI:ApiKey，请用 user-secrets 配置");
var endpoint = aiSection["Endpoint"] ?? "https://api.openai.com/v1";
var modelId = aiSection["ModelId"] ?? "gpt-4o-mini";

builder.Services.AddChatClient(_ =>
{
    var client = new OpenAIClient(
        new ApiKeyCredential(apiKey),
        new OpenAIClientOptions { Endpoint = new Uri(endpoint) });

    return client.GetChatClient(modelId).AsIChatClient();
});

// ---- 业务服务 ----
builder.Services.AddSingleton<OrderRepository>();
builder.Services.AddSingleton<AgentTools>();   // 工具无状态，单例即可
builder.Services.AddScoped<AgentService>();    // 每个用户连接一个实例

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error", createScopeForErrors: true);
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseAntiforgery();
app.MapStaticAssets();                       // .NET 9+；.NET 8 用 app.UseStaticFiles()
app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

app.Run();

Azure OpenAI 的写法：换成 new AzureOpenAIClient(new Uri(endpoint), new AzureKeyCredential(apiKey)).GetChatClient(deploymentName).AsIChatClient()，ModelId 填「部署名」而不是模型名。这是新手最容易踩的坑。

注意：AddChatClient 注册的是无状态客户端。会话记忆要在 AgentService / 组件里自己维护，不要指望客户端帮你记。

6. 定义工具（让模型能动手）

工具就是普通 C# 方法。AIFunctionFactory 会读它的方法名、参数名、参数类型、Description，自动生成 JSON Schema 交给模型。

6.1 模拟业务数据

Services/OrderRepository.cs：

namespace AgentStudio.Services;

public sealed record Order(
    string Id,
    string Customer,
    string Status,
    decimal Amount,
    DateTimeOffset CreatedAt);

public sealed class OrderRepository
{
    private readonly Dictionary<string, Order> _orders = new(StringComparer.OrdinalIgnoreCase)
    {
        ["A1001"] = new("A1001", "张三", "已发货", 299.00m, DateTimeOffset.Now.AddDays(-2)),
        ["A1002"] = new("A1002", "李四", "待付款", 88.50m, DateTimeOffset.Now.AddHours(-3)),
        ["B2001"] = new("B2001", "王五", "已退款", 1299.00m, DateTimeOffset.Now.AddDays(-15)),
    };

    public Order? Find(string orderId) =>
        _orders.TryGetValue(orderId.Trim(), out var order) ? order : null;
}

6.2 工具集合

Services/AgentTools.cs：

using Microsoft.Extensions.AI;
using System.ComponentModel;

namespace AgentStudio.Services;

public sealed class AgentTools(OrderRepository orders)
{
    /// <summary>一次性构建全部工具，避免每次请求重复反射。</summary>
    public IList<AITool> CreateTools() =>
    [
        AIFunctionFactory.Create(
            GetCurrentTime,
            "get_current_time",
            "获取服务器当前的日期、时间与时区。当用户问“现在几点”“今天几号”时调用。"),

        AIFunctionFactory.Create(
            QueryOrder,
            "query_order",
            "根据订单号查询订单的当前状态、金额与下单时间。当用户提供订单号并询问进度、发货、退款时调用。"),

        AIFunctionFactory.Create(
            Calculate,
            "calculate",
            "对两个数字执行四则运算。参数 op 只能是 + - * / 之一。"),
    ];

    [Description("获取当前时间，返回 yyyy-MM-dd HH:mm:ss 格式字符串。")]
    private string GetCurrentTime() =>
        DateTimeOffset.Now.ToString("yyyy-MM-dd HH:mm:ss zzz");

    [Description("按订单号查询订单。找不到时返回未找到提示，此时不要编造结果。")]
    private string QueryOrder(
        [Description("订单号，例如 A1001")] string orderId)
    {
        var order = orders.Find(orderId);
        return order is null
            ? $"未找到订单 {orderId}。请向用户确认单号是否正确。"
            : $"订单 {order.Id}：客户={order.Customer}，状态={order.Status}，" +
              $"金额={order.Amount:0.00} 元，下单于 {order.CreatedAt:yyyy-MM-dd HH:mm}";
    }

    [Description("执行四则运算并返回结果。")]
    private double Calculate(
        [Description("第一个数字")] double a,
        [Description("第二个数字")] double b,
        [Description("运算符，只能是 + - * /")] string op) => op switch
        {
            "+" => a + b,
            "-" => a - b,
            "*" => a * b,
            "/" when b != 0 => a / b,
            _ => double.NaN,
        };
}

6.3 写工具的四个硬性要求

最后一条尤其重要。 工具抛出的异常不会被模型看到，只会让你的请求中断。正确做法是把错误包装成字符串回填，模型往往能据此换一种问法或提示用户确认。

7. 实现智能体主循环

这是整个教程的核心。Microsoft.Extensions.AI 提供了 .UseFunctionInvocation() 中间件，一行就能自动跑循环；但建议先手写一遍，否则出问题时你完全不知道发生了什么。

7.1 流式数据块

Models/AgentChunk.cs：

namespace AgentStudio.Models;

public enum AgentChunkKind
{
    /// <summary>模型输出的正文增量。</summary>
    Text,
    /// <summary>模型发起了一次工具调用。</summary>
    ToolCall,
    /// <summary>工具执行完成并返回了结果。</summary>
    ToolResult,
}

/// <summary>传给 UI 的最小单位，Text/Assistant 正文走流式，工具事件走侧栏。</summary>
public readonly record struct AgentChunk(AgentChunkKind Kind, string Value)
{
    public static AgentChunk Text(string text) => new(AgentChunkKind.Text, text);
    public static AgentChunk ToolCall(string name) => new(AgentChunkKind.ToolCall, name);
    public static AgentChunk ToolResult(string text) => new(AgentChunkKind.ToolResult, text);
}

7.2 AgentService

Services/AgentService.cs：

using AgentStudio.Models;
using Microsoft.Extensions.AI;
using System.Runtime.CompilerServices;

namespace AgentStudio.Services;

public sealed class AgentService(
    IChatClient chatClient,
    AgentTools tools,
    IConfiguration configuration,
    ILogger<AgentService> logger)
{
    private readonly int _maxIterations = configuration.GetValue("AI:MaxIterations", 6);

    /// <summary>
    /// 跑一轮「模型 ⇄ 工具」循环，边跑边把增量交给 UI。
    /// history 由调用方负责拼接（系统提示 + 历史消息 + 本轮用户消息）。
    /// </summary>
    public async IAsyncEnumerable<AgentChunk> RunAsync(
        IReadOnlyList<ChatMessage> history,
        [EnumeratorCancellation] CancellationToken cancellationToken = default)
    {
        var messages = new List<ChatMessage>(history);
        var availableTools = tools.CreateTools();
        var options = new ChatOptions
        {
            Temperature = 0.3f,
            Tools = availableTools,
        };

        for (var iteration = 0; iteration < _maxIterations; iteration++)
        {
            var turnContents = new List<AIContent>();  // 本轮模型产出的所有内容
            var pendingCalls = new List<FunctionCallContent>();

            // ---- ① 请求模型（流式）----
            await foreach (var update in chatClient.GetStreamingResponseAsync(
                               messages, options, cancellationToken))
            {
                foreach (var content in update.Contents)
                {
                    turnContents.Add(content);

                    switch (content)
                    {
                        case TextContent { Text.Length: > 0 } text:
                            yield return AgentChunk.Text(text.Text);
                            break;

                        case FunctionCallContent call:
                            pendingCalls.Add(call);
                            yield return AgentChunk.ToolCall(call.Name);
                            break;
                    }
                }
            }

            // ---- ② 把模型这一轮的输出写回历史（含工具调用意图）----
            messages.Add(new ChatMessage(ChatRole.Assistant, turnContents));

            if (pendingCalls.Count == 0)
            {
                yield break;   // 模型选择直接回答，本轮结束
            }

            // ---- ③ 执行工具，把结果写回历史 ----
            var toolResults = new List<AIContent>();
            foreach (var call in pendingCalls)
            {
                cancellationToken.ThrowIfCancellationRequested();

                var function = availableTools
                    .OfType<AIFunction>()
                    .FirstOrDefault(f => f.Name == call.Name);

                var result = function is null
                    ? $"错误：不存在名为 {call.Name} 的工具，请改用可用工具或直接回答。"
                    : await InvokeSafelyAsync(function, call, cancellationToken);

                toolResults.Add(new FunctionResultContent(call.CallId, result));
                yield return AgentChunk.ToolResult($"{call.Name} → {result}");
            }

            messages.Add(new ChatMessage(ChatRole.Tool, toolResults));

            // 循环回到 ①，模型带着工具结果继续推理
        }

        logger.LogWarning("达到最大工具调用轮数 {Max}，强制收尾", _maxIterations);
        yield return AgentChunk.Text("\n\n（本轮工具调用次数已达上限，以上是目前能确定的信息。）");
    }

    private async Task<string> InvokeSafelyAsync(
        AIFunction function,
        FunctionCallContent call,
        CancellationToken cancellationToken)
    {
        try
        {
            var arguments = new AIFunctionArguments(call.Arguments);
            var value = await function.InvokeAsync(arguments, cancellationToken);
            var text = value?.ToString() ?? "";

            // 工具返回值会占用上下文窗口，做一次硬截断
            return text.Length <= 2000 ? text : text[..2000] + "…（已截断）";
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "工具 {Tool} 执行失败", function.Name);
            return $"工具执行失败：{ex.Message}，请换一种方式或告知用户稍后再试。";
        }
    }
}

7.3 为什么必须加这三道保险

两种实现方式二选一：上面是手写循环。若只想要结果，可在 Program.cs 的 AddChatClient(...) 后面链式加 .UseFunctionInvocation()，它会自动帮你执行工具并重试。两者不要同时用，否则工具会被执行两遍。

8. Blazor 聊天界面与流式输出

8.1 页面组件

Components/Pages/Chat.razor：

@page "/chat"
@using AgentStudio.Models
@using Microsoft.Extensions.AI
@inject AgentService Agent
@implements IDisposable

<PageTitle>智能体对话</PageTitle>

<div class="chat-shell">
    <div class="chat-log">
        @if (_messages.Count == 0)
        {
            <p class="hint">试试问我：A1001 这个订单现在什么状态？</p>
        }

        @foreach (var msg in _messages)
        {
            <div class="bubble @msg.Role">
                @if (msg.Trace.Count > 0)
                {
                    <details class="trace" open="@(msg.Role == "assistant" && msg.Text.Length == 0)">
                        <summary>工具调用 @msg.Trace.Count 次</summary>
                        <ul>
                            @foreach (var line in msg.Trace)
                            {
                                <li>@line</li>
                            }
                        </ul>
                    </details>
                }
                <div class="text">@msg.Text</div>
            </div>
        }
    </div>

    <div class="composer">
        <textarea @bind="_input" @bind:event="oninput"
                  @onkeydown="OnKeyDown"
                  placeholder="输入问题，Enter 发送，Shift+Enter 换行"
                  disabled="@_busy"></textarea>
        <button class="send" @onclick="SendAsync" disabled="@_busy">
            @(_busy ? "思考中…" : "发送")
        </button>
        @if (_busy)
        {
            <button class="stop" @onclick="Cancel">停止</button>
        }
    </div>
</div>

@code {
    private sealed class UiMessage(string role, string text)
    {
        public string Role { get; } = role;
        public string Text { get; set; } = text;
        public List<string> Trace { get; } = [];
    }

    private readonly List<UiMessage> _messages = [];
    private string _input = "";
    private bool _busy;
    private CancellationTokenSource? _cts;

    private const string SystemPrompt = """
        你是一个严谨的企业内部助手。必须遵守：
        1. 涉及订单、时间、金额计算等事实，先调用工具获取，禁止凭记忆猜测。
        2. 工具返回「未找到」时，向用户确认输入，不要编造答案。
        3. 用简洁的中文回答，数据较多时用要点列出。
        """;

    private async Task OnKeyDown(KeyboardEventArgs e)
    {
        if (e.Key == "Enter" && !e.ShiftKey)
        {
            await SendAsync();
        }
    }

    private async Task SendAsync()
    {
        var question = _input.Trim();
        if (question.Length == 0 || _busy)
        {
            return;
        }

        _input = "";
        _busy = true;

        _messages.Add(new UiMessage("user", question));

        // 关键：先取快照，再插入空的助手消息，避免把占位消息带进历史
        var history = BuildHistory();
        var answer = new UiMessage("assistant", "");
        _messages.Add(answer);

        _cts = new CancellationTokenSource(TimeSpan.FromMinutes(3));
        try
        {
            await foreach (var chunk in Agent.RunAsync(history, _cts.Token))
            {
                switch (chunk.Kind)
                {
                    case AgentChunkKind.Text:
                        answer.Text += chunk.Value;
                        break;
                    default:
                        answer.Trace.Add(chunk.Value);
                        break;
                }

                // 每来一个增量就重绘，这是「打字机效果」的来源
                await InvokeAsync(StateHasChanged);
            }
        }
        catch (OperationCanceledException)
        {
            answer.Text += "\n\n（已停止）";
        }
        catch (Exception ex)
        {
            answer.Text += $"\n\n**出错了：** {ex.Message}";
        }
        finally
        {
            _busy = false;
            _cts.Dispose();
            _cts = null;
        }
    }

    private List<ChatMessage> BuildHistory()
    {
        var list = new List<ChatMessage>
        {
            new(ChatRole.System, SystemPrompt),
        };

        foreach (var msg in _messages.Where(m => m.Text.Length > 0))
        {
            list.Add(new ChatMessage(
                msg.Role == "user" ? ChatRole.User : ChatRole.Assistant,
                msg.Text));
        }

        return list;
    }

    private void Cancel() => _cts?.Cancel();

    public void Dispose() => _cts?.Dispose();
}

8.2 三个容易踩的点

1. await InvokeAsync(StateHasChanged) 不能省。 如果只在方法结束时渲染一次，用户要等 20 秒才看到全部文字，「流式」就白做了。
2. 历史快照要在插入占位消息之前取。 否则最后一条空的 assistant 消息也会进上下文，某些模型会因此输出异常。
3. 一定要有取消能力。 Blazor Server 断线（关标签页）时 Dispose 会触发，配合 CancellationToken 及时释放服务端资源。

8.3 样式

追加到 wwwroot/app.css：

.chat-shell { display: flex; flex-direction: column; height: calc(100vh - 3.5rem); max-width: 860px; margin: 0 auto; }
.chat-log { flex: 1; overflow-y: auto; padding: 1rem; display: flex; flex-direction: column; gap: .75rem; }
.bubble { max-width: 80%; padding: .65rem .9rem; border-radius: .75rem; line-height: 1.6; white-space: pre-wrap; word-break: break-word; }
.bubble.user { align-self: flex-end; background: #2563eb; color: #fff; }
.bubble.assistant { align-self: flex-start; background: #f1f5f9; color: #0f172a; }
.trace { font-size: .8rem; color: #64748b; margin-bottom: .4rem; }
.trace ul { margin: .3rem 0 0; padding-left: 1rem; }
.composer { display: flex; gap: .5rem; padding: .75rem; border-top: 1px solid #e2e8f0; }
.composer textarea { flex: 1; min-height: 44px; max-height: 140px; padding: .5rem .75rem; border: 1px solid #cbd5e1; border-radius: .5rem; resize: vertical; }
.composer button { padding: 0 .9rem; border-radius: .5rem; border: none; cursor: pointer; }
.composer .send { background: #2563eb; color: #fff; }
.composer .stop { background: #ef4444; color: #fff; }
.hint { color: #94a3b8; text-align: center; margin-top: 2rem; }

最后在 Components/Layout/NavMenu.razor 里加一个入口：

<div class="nav-item px-3">
    <NavLink class="nav-link" href="chat">
        <span class="bi bi-robot-nav-menu" aria-hidden="true"></span> 智能体
    </NavLink>
</div>

运行：

dotnet run
# 浏览器打开  https://localhost:5001/chat ，输入「A1001 这个订单现在什么状态？」

成功标志：界面上先出现「工具调用 1 次」，展开能看到 query_order → 订单 A1001：…，随后正文逐字出现。这说明完整的「推理 → 调工具 → 回填 → 再推理」链路已经跑通。

9. 会话记忆

模型本身没有记忆。你每次请求都要把历史消息重新发一遍，它才「记得」上文。

9.1 三级记忆策略

先做第一级。Services/ChatSessionStore.cs（注册为 Scoped，在 Blazor Server 中等于「每个用户连接一个」）：

using Microsoft.Extensions.AI;

namespace AgentStudio.Services;

public sealed class ChatSessionStore
{
    private const int MaxMessages = 40;   // ≈ 20 轮对话
    private readonly List<ChatMessage> _messages = [];

    public IReadOnlyList<ChatMessage> Snapshot() => _messages.ToList();

    public void Add(ChatMessage message)
    {
        _messages.Add(message);

        // 超出上限时，从最早的「用户消息」开始成对丢弃，避免把 assistant 孤立
        while (_messages.Count > MaxMessages)
        {
            _messages.RemoveAt(0);
            if (_messages.Count > 0 && _messages[0].Role == ChatRole.Assistant)
            {
                _messages.RemoveAt(0);
            }
        }
    }

    public void Clear() => _messages.Clear();
}

在 Program.cs 注册：

builder.Services.AddScoped<ChatSessionStore>();

Chat.razor 里把 _messages 换成 Session（注意：UI 展示需要保留文本，所以通常两份并用——UI 列表用于渲染，ChatSessionStore 用于构造请求上下文）。

跨页面/跨刷新保留会话：把 Scoped 换成用 sessionId 做 key 的 Singleton + IMemoryCache（或 Redis），只存消息文本不存 AIFunction 对象。

9.2 什么时候该做摘要

对话超过 20 轮、或 token 成本明显上升时，用一次额外调用把旧消息压缩：

var summary = await chatClient.GetResponseAsync(
    $"请把下面的对话压缩成 200 字以内的要点，保留订单号、金额、用户诉求：\n\n{oldTranscript}");

然后把 summary.Text 作为一条 ChatRole.System 消息放到历史最前面，替换掉那批旧消息。

10. 结构化输出

当智能体的结果要交给下游代码（而不是给人看），让模型直接返回强类型对象，别去解析自然语言。

public sealed record TicketDraft(
    string Title,
    string Category,
    string Priority,
    string Summary);

var response = await chatClient.GetResponseAsync<TicketDraft>(
    [
        new ChatMessage(ChatRole.System, "你是工单分类助手，只输出结构化结果。"),
        new ChatMessage(ChatRole.User, "客户说：下单三天了还没发货，急！"),
    ]);

TicketDraft draft = response.Result;

配合工具使用时，建议把「需要决策」的部分交给结构化输出，把「需要事实」的部分交给工具，两者组合出来的智能体最稳。

11. 多智能体编排

单智能体超过 10 个工具后，模型的选择准确率会明显下降。这时拆成多个专职智能体，由一个协调者分发。

最小实现方式：把「另一个智能体」包装成一个工具。

public sealed class OrchestratorTools(
    [FromKeyedServices("billing")] IChatClient billingAgent,
    [FromKeyedServices("support")] IChatClient supportAgent)
{
    public IList<AITool> CreateTools() =>
    [
        AIFunctionFactory.Create(
            (string question) => AskAsync(billingAgent, "你是账单专家，只回答账务问题。", question),
            "ask_billing_agent",
            "把账务、发票、退款金额相关问题转给账单专家。"),

        AIFunctionFactory.Create(
            (string question) => AskAsync(supportAgent, "你是售后专家，只回答物流与售后问题。", question),
            "ask_support_agent",
            "把物流、退换货、使用问题转给售后专家。"),
    ];

    private static async Task<string> AskAsync(IChatClient agent, string prompt, string question)
    {
        var response = await agent.GetResponseAsync(
            [new ChatMessage(ChatRole.System, prompt), new ChatMessage(ChatRole.User, question)]);
        return response.Text;
    }
}

关键设计原则：

• 每个子智能体只暴露少量工具（3~5 个），职责单一；
• 子智能体之间不共享历史，只传问题文本，避免上下文爆炸；
• 需要复杂流转（A 做完交 B、带状态）时，再上 Semantic Kernel 的 Agent Framework，不要自己硬造轮子。

12. 生产化：安全、成本、可观测

12.1 安全（四条底线）

高风险操作加人工确认（比如「退款」「删除」）：让工具返回 "需要用户确认"，界面弹出确认按钮，用户点击后才真正执行。这一层一定要放在你的 C# 代码里，不要指望模型自觉。

12.2 成本控制

• 限流：按用户或会话设置每分钟请求数上限（RateLimiter 中间件）；
• 上下文裁剪：按第 9 节的策略丢弃旧消息，别无限增长；
• 模型分级：意图识别用小模型，复杂推理用大模型；
• 工具返回值瘦身：只回传模型需要的字段；
• 记录 token 用量：ChatResponse.Usage 里有输入/输出 token 数，写进日志做成本报表。

12.3 可观测性

_logger.LogInformation(
    "agent turn={Turn} tools={Tools} inputTokens={In} outputTokens={Out} elapsed={Elapsed}ms",
    turn, string.Join(",", toolNames), usage?.InputTokenCount, usage?.OutputTokenCount,
    stopwatch.ElapsedMilliseconds);

至少要能回答三个问题：这一轮模型调了哪些工具？花了多少 token？耗时多少？没有这些数据，线上出问题只能靠猜。

Microsoft.Extensions.AI 自带 OpenTelemetry 埋点，配置 AddOpenTelemetry().WithTracing(t => t.AddSource("Experimental.Microsoft.Extensions.AI")) 后可直接接入 Jaeger / Aspire Dashboard。

13. 常见坑与排错表

14. 练手路线

按顺序做，每一步都能独立跑通再往下走：

1. 加一个「查库存」工具：照抄 QueryOrder 的结构，体会工具注册的套路。
2. 加人工确认：给「申请退款」工具加确认弹窗，未确认前返回 "等待用户确认"。
3. 做摘要记忆：对话超过 20 轮自动压缩，观察 token 用量变化。
4. 接入真实数据：把 OrderRepository 换成 EF Core + SQL Server，注意连接串同样走 user-secrets。
5. 加 RAG：文档切片 → 向量化 → 存 SQLite/Qdrant → 检索结果作为一个 search_docs 工具。
6. 拆分多智能体：账单 / 售后 / 技术三路，观察路由准确率。
7. 部署：Linux + Nginx，注意 SignalR 需要 proxy_set_header Upgrade / Connection，并且 UseForwardedHeaders。

附录 A：完整文件清单与运行方式

AgentStudio/
├── Program.cs
├── appsettings.json
├── Models/AgentChunk.cs
├── Services/
│   ├── OrderRepository.cs
│   ├── AgentTools.cs
│   ├── AgentService.cs
│   └── ChatSessionStore.cs
├── Components/
│   ├── App.razor
│   ├── Routes.razor
│   ├── Layout/NavMenu.razor
│   └── Pages/Chat.razor
└── wwwroot/app.css

首次运行：

dotnet user-secrets set "AI:ApiKey" "sk-你的密钥"
dotnet run

验收清单：

全部通过，你就拥有了一个可以继续往上叠业务的最小智能体骨架。剩下的工作，本质上就是不断往 AgentTools 里加工具，以及把系统提示写得越来越贴合你的业务。