❝摘要：在这个人人都在谈AI的时代，有人还在用ChatGPT复制粘贴，有人已经在玩Agent协作了。今天给大家聊聊如何用微软刚发布的Agent Framework，搞出一个能自己收集资料、撰写博客、还能自我审查的"打工人三件套"系统。
在这个人人都在谈AI的时代，有人还在用ChatGPT复制粘贴，有人已经在玩Agent协作了。今天给大家聊聊如何用微软刚发布的Agent Framework，搞出一个能自己收集资料、撰写博客、还能自我审查的"打工人三件套"系统。
一、从一个真实痛点说起说实话，作为一个技术博主，我最怕的就是三件事：
找资料累成狗- 打开几十个标签页，复制粘贴到凌晨两点，最后发现资料太乱理不清头绪写作没思路- 盯着空白文档三小时，憋出来的开头自己都觉得尴尬质量没把握- 写完了不知道质量如何，发出去被大佬指正错误时社死直到某天，我突然意识到：这不就是三个独立的任务吗？要是有三个专家分别负责这些事，该多香啊！
于是，BlogAgent这个项目就诞生了。但这次我不打算自己造轮子——微软已经把Agent Framework开源了，为啥不直接拿来用？
以前玩AI应用，基本是这么个流程：
// 老派做法：手动管理一切var prompt = $"你是专家，请帮我{任务}，要求{一大堆要求}...";
var response = await openai.GetCompletionAsync(prompt);
// 然后祈祷返回的内容能用...
状态管理靠人品- 多轮对话？自己拼字符串吧工具调用像碰运气- Function Calling返回格式不对？改Prompt再来一遍流程编排全靠脑补- 多个任务串联？写一堆if-else伺候
而Agent Framework的出现，直接把这些脏活累活全包了。它的核心理念就一句话：
❝把AI能力抽象成Agent，把业务流程编排成Workflow
2.2 Agent Framework的三板斧看看这个架构图就懂了：
┌─────────────────────────────────────────────────────┐│ 你的业务逻辑 │
│ (创建博客、处理订单、分析数据...) │
└────────────────────┬────────────────────────────────┘
│
┌────────────────────▼────────────────────────────────┐
│ Agent Framework Workflow Layer │
│ ┌──────────────────────────────────────────┐ │
│ │ 声明式工作流编排 │ │
│ │ (Sequential, Concurrent, GroupChat...) │ │
│ └──────┬─────────────────────────────────┬─┘ │
│ │ │ │
│ ┌──────▼────────┐ ┌────────────────────▼───┐ │
│ │ Agent 1 │ │ Agent 2 │ │
│ │ (Researcher) │→ │ (Writer) │ │
│ └───────────────┘ └─────────────────────────┘ │
└────────────────────────┬────────────────────────────┘
│
┌────────────────────────▼────────────────────────────┐
│ Microsoft.Extensions.AI │
│ (统一的AI抽象层) │
└─────────────────────────────────────────────────────┘
第一板斧：Agent抽象
每个Agent就是一个有特定技能的专家。比如我的ResearcherAgent，专门负责资料收集：
public classResearcherAgent : BaseAgentService{
publicoverridestring AgentName => "资料收集专家";
protectedoverridestring Instructions => @"
你是一位专业的技术资料收集专家。
任务：提取关键信息、整理代码示例、生成结构化摘要
输出：严格的JSON格式
";
// 给Agent配工具
protectedoverride IEnumerable
{
AIFunctionFactory.Create(CountWordsInText),
AIFunctionFactory.Create(ExtractCodeBlocks)
};
// 要求输出结构化数据
protectedoverride ChatResponseFormat? ResponseFormat =>
ChatResponseFormat.ForJsonSchema
schemaName: "ResearchOutput"
);
}
看到没？Agent不再是一个黑盒子，而是有明确的：
职责定位(Instructions)工具能力(Tools)输出约束(ResponseFormat)第二板斧：Workflow编排
以前多个Agent协作，要写一堆状态机代码。现在呢？声明式搞定：
// 顺序执行：研究 → 撰写 → 审查var workflow = AgentWorkflowBuilder.BuildSequential(
"BlogGenerationWorkflow",
researcherAgent,
writerAgent,
reviewerAgent
);
// 执行工作流，自动管理状态和数据传递
var run = await InProcessExecution.StreamAsync(workflow, messages);
三行代码，完事。状态管理？数据传递？错误重试？框架全包了。
第三板斧：工具集成（Tools）
Agent可以调用C，就像调用自己的手脚一样自然：
[Description("统计文本字数,包括中文字符和英文单词")]private static int CountWordsInText(
[Description("要统计的文本内容")] string text)
{
int chineseChars = text.Count(c => c >= 0x4E00 && c 0x9FA5);
int englishWords = text.Split(' ')
.Count(word => word.Any(char.IsLetter));
return chineseChars + englishWords;
}
AI看到这个工具，会自动判断什么时候该调用它。比如你问"这篇文章多少字？"，它就会自动call这个函数。
三、BlogAgent的"三个火枪手"架构3.1 火枪手一号：ResearcherAgent（资料收集专家）这家伙的任务是把乱七八糟的参考资料，整理成结构化的知识图谱。
输入：
用户直接粘贴的文本
上传的文档（PDF、Word、Markdown都支持）
一堆URL链接（自动抓取内容）
输出：
{"topic_analysis": "这是一篇关于Agent Framework的技术文章...",
"key_points": [
{
"importance": 3,
"content": "Agent Framework使用声明式工作流"
}
],
"technical_details": [
{
"title": "Workflow构建器",
"description": "AgentWorkflowBuilder提供三种模式..."
}
],
"code_examples": [
{
"language": "csharp",
"code": "var workflow = AgentWorkflowBuilder...",
"description": "构建顺序工作流的示例"
}
]
}
注意这里的黑科技：结构化输出（Structured Output）。
以前让AI返回JSON，基本靠人品：
它可能给你返回 {代码块里的JSON} 也可能返回 这是JSON：{...}还有一堆废话更有可能返回个格式错误的JSON让你解析崩溃
现在用JSON Schema约束，AI必须按照你定义的格式返回：
protected override ChatResponseFormat? ResponseFormat =>ChatResponseFormat.ForJsonSchema
schemaName: "ResearchOutput"
);
一行代码，保证输出可靠性。这就是框架的魅力。
3.2 火枪手二号：WriterAgent（博客撰写专家）拿到ResearcherAgent整理好的资料后，WriterAgent开始干活。
这家伙的Instructions写得很细：
protected override string Instructions => @"你是一位资深技术博客作家，擅长将技术内容转化为通俗易懂的文章。
**文章结构(严格按照以下格式):**
# 标题
> 引言(一段吸引读者的导语)
## 一、背景介绍
[技术背景、为什么需要这个技术]
## 二、核心概念
[关键概念详细解释]
## 三、实战应用
[代码示例和使用场景]
## 四、最佳实践
[经验总结、注意事项]
## 五、总结
[全文总结、技术展望]
**质量标准:**
- 字数不少于1500字(根据用户要求调整)
- 代码示例使用```代码块,标注语言类型
- 避免空洞的套话和无意义的形容词
- 逻辑流畅,前后呼应
";
为什么写这么细？因为AI就像实习生，你不告诉它标准，它就会发挥"创意"。
关键配置：
protected override int MaxTokens => 6000; // 支持长文输出默认MaxTokens是4000，但写博客往往需要更多。这个参数直接影响输出质量，别省。
3.3 火枪手三号：ReviewerAgent（质量审查专家）这家伙是个严格的审查员，给博客打分并提改进建议。
评分维度：
维度
权重
说明
准确性 40% 技术内容是否准确 逻辑性 30% 文章结构是否清晰 原创性 20% 内容是否有新意 规范性 10% 格式和排版是否标准输出示例：
{"overall_score": 85,
"accuracy": {
"score": 38,
"issues": ["某处技术描述不够精确"],
"suggestions": ["建议补充更多技术细节"]
},
"logic": {
"score": 28,
"issues": ,
"suggestions": ["文章逻辑连贯，建议保持"]
},
"recommendation": "建议发布"
}
关键在于这个Agent的Temperature设置：
protected override float Temperature => 0.3f; // 低温度保证稳定审查工作需要一致性，不能今天说好明天说不好。所以把Temperature设低，让它"理智"一点。
四、工作流编排的艺术4.1 两种模式：全自动 vs 分步控制全自动模式：
public async Task ExecuteFullWorkflowAsync(int taskId){
// 构建工作流
var workflow = await BuildBlogWorkflowAsync;
// 准备输入
var input = $@"
**主题:** {task.Topic}
**参考资料:** {referenceContent}
**撰写要求:** 字数{targetWords}，风格{style}
";
// 一键执行全流程
var messages = new List
new ChatMessage(ChatRole.User, input)
};
awaitusingvar run = await InProcessExecution.StreamAsync(
workflow,
messages
);
// 发送执行令牌
await run.TrySendMessageAsync(new TurnToken(emitEvents: true));
// 监听工作流事件
awaitforeach (var evt in run.WatchStreamAsync)
{
if (evt is AgentRunUpdateEvent agentUpdate)
{
// 实时更新进度
UpdateProgress(taskId, agentUpdate);
}
elseif (evt is WorkflowOutputEvent output)
{
// 处理最终输出
await ProcessWorkflowOutputAsync(taskId, output);
break;
}
}
}
点一下按钮，泡杯咖啡回来就写好了。适合批量生产。
分步模式：
// 用户手动触发每个阶段await ExecuteStageAsync(taskId, "research"); // 先收集资料
// 用户检查结果，满意了继续
await ExecuteStageAsync(taskId, "write"); // 再撰写博客
// 用户检查草稿，可以编辑
await ExecuteStageAsync(taskId, "review"); // 最后审查质量
// 根据评分决定是否发布
适合需要人工把关的场景。
4.2 工作流事件监听：实时进度反馈用户最怕的就是点了按钮之后，屏幕一片空白，不知道系统在干嘛。
Agent Framework的事件系统解决了这个问题：
await foreach (var evt in run.WatchStreamAsync){
if (evt is AgentRunUpdateEvent agentUpdate)
{
// 检测Agent切换
if (agentUpdate.ExecutorId?.Contains("Researcher") == true)
{
UpdateProgress(taskId, new WorkflowProgressDto
{
CurrentStep = 0,
StepName = "资料收集",
Status = "running",
Message = "ResearcherAgent 正在分析主题...",
CurrentOutput = $" 开始分析主题: {task.Topic}"
});
}
elseif (agentUpdate.ExecutorId?.Contains("Writer") == true)
{
{
CurrentStep = 1,
StepName = "博客撰写",
Status = "running",
Message = "WriterAgent 正在撰写博客...",
CurrentOutput = $" 目标字数: {targetWords} 字"
});
}
// 实时显示Agent的输出
if (!string.IsnullOrEmpty(agentUpdate.Update.Text))
{
currentOutput += agentUpdate.Update.Text;
UpdateUI(currentOutput); // 实时更新界面
}
}
}
这样用户就能看到：
当前执行到哪个Agent了
Agent正在生成什么内容
预计还要等多久
体验直接拉满。
五、MCP协议：Agent的"外挂商店"5.1 什么是Model Context Protocol？简单说，MCP就是一个标准化的"工具接口协议"。
以前你想让Agent调用外部API，得：
每接一个新服务，重复三遍。
有了MCP，事情变简单了：
// 添加MCP服务器配置var mcpServer = new McpServerConfig
{
Name = "GitHub MCP Server",
TransportType = "stdio",
Command = "npx",
Arguments = ["-y", "@modelcontextprotocol/server-github"],
IsEnabled = true
};
// Agent自动加载所有MCP工具
var agent = await GetAgentAsync; // 已经包含GitHub的所有工具了
现在Agent就能：
list_repositories- 列出你的仓库search_code- 搜索代码get_file_content- 读取文件内容全是现成的，开箱即用。
5.2 BlogAgent的MCP集成我给BlogAgent加了MCP配置页面，可以动态添加工具：
支持两种模式：
{"name": "GitHub Tools",
"transportType": "stdio",
"command": "npx",
"arguments": ["-y", "@modelcontextprotocol/server-github"],
"environmentVariables": {
"GITHUB_TOKEN": "your_token"
}
}
{
"name": "Weather Service",
"transportType": "http",
"serverUrl": "http://weather-mcp.example.com/",
"requiresAuth": true,
"oauthClientId": "your_client_id"
}
Agent自动集成：
public abstractclassBaseAgentService{
protectedvirtualbool EnableMcpTools => true; // 是否启用MCP
protectedvirtualasync Task
{
var toolsList = new List
// 添加Agent自定义工具
if (Tools != null)
toolsList.AddRange(Tools);
// 添加MCP工具
if (EnableMcpTools && _mcpConfigService != null)
{
var mcpTools = await _mcpConfigService
.GetAllEnabledToolsAsync
.WaitAsync(TimeSpan.FromSeconds(15)); // 超时保护
if (mcpTools != null)
toolsList.AddRange(mcpTools);
}
return toolsList.Count > 0 ? toolsList : null;
}
}
这样设计的好处：
✅ 向后兼容- 不影响现有Agent ✅ 按需启用- 每个Agent可以选择是否用MCP ✅ 自动加载- 配置好就能用，无需改代码六、Blazor Server：现代化的UI选择6.1 为什么选Blazor而不是React/Vue？很多人会问：都2025年了，为啥不用React？
原因很简单：全C，VibeCoding 开发效率高到飞起。整个项目我只用了不到2天时间！！！
看这个对比：
传统前后端分离：
前端 (TypeScript/React)↓ HTTP API ↓
后端 (C#/.NET)
↓
数据库
痛点：
1. 维护两套类型定义
2. API接口文档容易过期
3. 前后端联调效率低
4. 部署两个项目
Blazor Server：
UI (Razor Components - C#)↓ SignalR WebSocket ↓
后端逻辑 (C#)
↓
数据库
优势：
1. 一套类型定义，编译时检查
2. 共享C
3. 实时双向通信（SignalR）
4. 单项目部署
6.2 实时进度更新的实现
Blazor Server的杀手锏是SignalR自动管理的WebSocket连接。
传统方式（轮询）：
// 前端每秒请求一次setInterval(async => {
const progress = await fetch('/api/workflow/progress');
updateUI(progress);
}, 1000);
服务器压力大，延迟高，浪费带宽。
Blazor方式（实时推送）：
// 后端更新进度UpdateProgress(taskId, new WorkflowProgressDto
{
CurrentStep = 1,
Status = "running",
Message = "正在撰写博客..."
});
// 前端自动刷新
@code {
private WorkflowProgressDto? Progress { get; set; }
protected override async Task OnInitializedAsync
{
// 启动后台任务
_ = Task.Run(async =>
{
while (!Progress?.IsCompleted ?? true)
{
Progress = WorkflowService.GetWorkflowProgress(TaskId);
await InvokeAsync(StateHasChanged); // 触发UI更新
await Task.Delay(500);
}
});
}
}
SignalR自动处理重连、心跳、序列化，你只管写业务逻辑。
6.3 Ant Design Blazor：开箱即用的企业级组件不想自己写Button、Table、Modal？Ant Design Blazor都给你准备好了：
DataSource="@tasks"Loading="@loading">OnClick=" => NavigateTo($"/blog/workflow/{context.Id}")">查看详情OnConfirm=" => DeleteTask(context.Id)">设计风格统一，响应式适配，还有深色模式。美滋滋。
七、踩过的坑与最佳实践7.1 结构化输出的正确姿势坑：AI可能返回带废话的JSON
即使你设置了ChatResponseFormat.ForJsonSchema，有些模型还是会返回：好的，我来生成JSON：{
"topic_analysis": "..."
}
希望这个结果对你有帮助！
解决方案：
private T? ParseJsonResponse{
try
{
// 先尝试直接解析
return JsonSerializer.Deserialize
}
catch
{
// 提取第一个完整的JSON对象
var startIndex = jsonContent.IndexOf('{');
var endIndex = jsonContent.LastIndexOf('}');
if (startIndex >= 0 && endIndex > startIndex)
{
var jsonStr = jsonContent.Substring(
startIndex,
endIndex - startIndex + 1
);
}
returnnull;
}
}
7.2 MCP工具加载超时问题
坑：启动MCP客户端可能很慢
特别是Stdio模式，要启动Node.js进程，可能要3-5秒。如果同步加载，Agent创建会卡死。
解决方案：
protected virtualasync Task{
// ...
try
{
// 添加超时保护
usingvar cts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
var mcpTools = await _mcpConfigService
.GetAllEnabledToolsAsync
.WaitAsync(cts.Token) // 15秒超时
.ConfigureAwait(false);
// ...
}
catch (OperationCanceledException)
{
_logger.LogWarning("加载MCP工具超时，跳过");
// 继续执行，不影响Agent创建
}
}
7.3 Workflow事件处理的注意事项
坑：事件可能丢失或重复
Workflow的事件流是异步的，如果处理太慢可能丢事件。
解决方案：
// 使用字典缓存Agent输出var agentOutputs = new Dictionarystring, string>;
awaitforeach (var evt in run.WatchStreamAsync)
{
if (evt is AgentRunUpdateEvent agentUpdate)
{
// 检测Agent切换
if (agentUpdate.ExecutorId != lastExecutorId)
{
lastExecutorId = agentUpdate.ExecutorId;
agentOutputs[agentUpdate.ExecutorId!] = ""; // 初始化
}
// 累积输出
if (!string.IsNullOrEmpty(agentUpdate.Update.Text))
{
agentOutputs[agentUpdate.ExecutorId!] += agentUpdate.Update.Text;
}
}
}
// 最后统一处理完整输出
await ProcessWorkflowOutputAsync(taskId, agentOutputs);
7.4 Token限制与成本控制
坑：长文生成容易超限
WriterAgent要生成4000+字的博客，输入+输出轻松超过8000 tokens。
最佳实践：
// 先生成大纲var outline = await GenerateOutlineAsync(topic);
// 按章节生成内容
foreach (var section in outline.Sections)
{
var sectionContent = await GenerateSectionAsync(section);
fullContent += sectionContent;
}
{
"ResearcherAgent": "gpt-4o-mini", // 便宜，够用
"WriterAgent": "gpt-4o", // 贵但质量高
"ReviewerAgent": "gpt-4o-mini" // 便宜，够用
}
// ResearchAgent的输出缓存起来
// 改进WriterAgent的Prompt不需要重新收集资料
var cachedResearch = _memoryCache.Get
if (cachedResearch == null)
{
cachedResearch = await _researcherAgent.ResearchAsync(...);
_memoryCache.Set(taskId, cachedResearch, TimeSpan.FromHours(1));
}
八、性能与可观测性8.1 执行时间统计
BlogAgent的典型执行时间（gpt-4o模型）：
阶段
平均耗时
Token消耗
资料收集 8-12秒 ~2000 博客撰写 25-40秒 ~5000 质量审查 10-15秒 ~3000 总计43-67秒~10000成本估算：
gpt-4o: 0.015/1K output ≈ $0.12/篇 gpt-4o-mini: 便宜10倍，约 $0.012/篇批量生产100篇博客，用gpt-4o成本$12，可以接受。
8.2 可观测性增强（TODO）目前计划接入OpenTelemetry，实现：
using System.Diagnostics;publicabstractclassBaseAgentService
{
protectedstaticreadonly ActivitySource ActivitySource = new("BlogAgent");
public override async Taskstring> ExecuteAsync(string input, int taskId)
{
usingvar activity = ActivitySource.StartActivity($"{AgentName}.Execute");
activity?.SetTag("agent.name", AgentName);
activity?.SetTag("task.id", taskId);
var stopwatch = Stopwatch.StartNew;
try
{
var result = await agent.RunAsync(input, thread);
activity?.SetTag("execution.duration_ms", stopwatch.ElapsedMilliseconds);
activity?.SetTag("output.length", result.Text.Length);
activity?.SetStatus(ActivityStatusCode.Ok);
return result.Text;
}
catch (Exception ex)
{
activity?.SetTag("error.type", ex.GetType.Name);
activity?.SetStatus(ActivityStatusCode.Error);
throw;
}
}
}
接入Azure Application Insights后，就能看到：
每个Agent的平均执行时间趋势
Token消耗和成本统计
完整的调用链路追踪
⚠️ 异常率和失败原因分析
九、未来规划：更多可能性9.1 流式输出（Streaming）目前是等Agent全部生成完才显示，体验不够实时。
计划实现：
public async IAsyncEnumerablestring> ExecuteStreamingAsync(string input,
int taskId)
{
var agent = await GetAgentAsync;
var thread = await GetNewThreadAsync;
await foreach (var update in agent.RunStreamingAsync(input, thread))
{
if (!string.IsNullOrEmpty(update.Text))
{
yield return update.Text;
}
}
}
前端实时渲染：
@code {private string streamingContent = "";
private async Task ExecuteWithStreaming
{
await foreach (var chunk in WorkflowService.ExecuteStreamingAsync(TaskId))
{
streamingContent += chunk;
await InvokeAsync(StateHasChanged); // 实时更新UI
}
}
}
用户就能像看ChatGPT打字一样，看着博客被生成出来。
9.2 RAG增强（检索增强生成）现在的BlogAgent是"无记忆"的，每次生成都从零开始。
计划集成向量数据库：
public classRAGResearcherAgent : ResearcherAgent{
privatereadonly IVectorStore _vectorStore;
public async Task ResearchWithRAGAsync(
string topic,
string userContent)
{
// 1. 从知识库检索相关历史博客
var similarBlogs = await _vectorStore.SearchAsync(
query: topic,
topK: 3
);
// 2. 构造增强Prompt
var enhancedInput = $@"
**主题:** {topic}
**用户提供的资料:**
{userContent}
**知识库检索到的相关内容(供参考):**
{string.Join("\n\n", similarBlogs)}
请综合以上内容,生成结构化摘要。
";
// 3. 调用Agent
returnawait ExecuteAsync(enhancedInput, taskId);
}
}
好处：
✅ 自动引用历史经验
✅ 保持写作风格一致性
✅ 避免重复劳动
9.3 并发工作流（Concurrent Workflow）现在是串行执行，能不能并行加速？
场景1：多源资料并行收集
// 同时从GitHub、Stack Overflow、官方文档收集资料var workflow = AgentWorkflowBuilder.BuildConcurrent(
"ParallelResearch",
new { githubResearcher, stackoverflowResearcher, docsResearcher },
aggregator: results => MergeResults(results)
);
场景2：多维度并行审查
// 技术审查、文风审查、SEO审查并行var reviewWorkflow = new ConcurrentBuilder
.Participants(new {
technicalReviewer,
styleReviewer,
seoReviewer
})
.Build;
理论上能提速50%+。
9.4 条件路由（Conditional Routing）根据审查结果自动决定下一步：
private Liststring> SelectNextStep(ReviewResult review){
return review.OverallScore switch
{
>= 90 => ["publisherId"], // 直接发布
>= 70 => ["revisionAgentId"], // 需要修改
>= 50 => ["rewriteAgentId"], // 重写部分内容
_ => ["rejectHandlerId"] // 拒绝
};
}
var workflow = new WorkflowBuilder
.SetStartExecutor(writerAgent)
.AddEdge(writerAgent, reviewerAgent)
.AddMultiSelectionEdgeGroup(
reviewerAgent,
new { publisher, revisionAgent, rewriteAgent, rejectHandler },
selectionFunc: SelectNextStep
)
.Build;
真正的"智能"工作流。
十、总结：Agent时代的开发范式转变10.1 三个核心观念转变从"调用API"到"编排Agent"
以前：
var response = await openai.ChatCompletionAsync(prompt);现在：
var workflow = AgentWorkflowBuilder.BuildSequential(researcherAgent, writerAgent, reviewerAgent
);
var result = await InProcessExecution.RunAsync(workflow, input);
从"Prompt工程"到"Agent设计"
以前：花80%时间调Prompt，祈祷输出格式对现在：定义Agent角色、工具、输出约束，框架保证质量
从"单次交互"到"多轮协作"
以前：一次对话解决所有问题（往往解决不了）现在：多个专业Agent分工协作，每个干好自己的事
10.2 BlogAgent的技术价值这不只是一个博客生成工具，更是一个：
✅ Agent Framework的最佳实践示例 ✅ Blazor Server的企业级应用模板 ✅ MCP协议集成的参考实现 ✅ AI工作流编排的教学案例10.3 适用场景BlogAgent的架构可以直接迁移到：
内容生产- 新闻稿、产品文档、技术白皮书代码生成- 需求分析 → 代码实现 → 代码审查数据分析- 数据收集 → 分析报告 → 可视化建议客服系统- 意图识别 → 问题解答 → 满意度评估只要你的业务能拆成多个步骤，就能用Agent工作流实现。
10.4 结语微软Agent Framework才刚发布，还在快速迭代。但它已经展现出强大的潜力：
降低门槛- 不需要深厚的AI知识，会C提升效率- 声明式编排，少写90%的胶水代码保证质量- 结构化输出、工具约束、状态管理全包了AI应用的开发，正在从"黑魔法艺术"变成"工程化科学"。
而你，准备好迎接Agent时代了吗？
附录：快速开始环境要求.NET 9.0 SDK
OpenAI API Key（或兼容的服务）
Node.js/python/dotnet10等（如需使用MCP工具）
克隆运行git clone https://github.com/xuzeyu91/BlogAgent.gitcd BlogAgent
# 配置API Key
# 编辑 BlogAgent/appsettings.json
dotnet restore
dotnet build
cd BlogAgent
dotnet run
# 访问 http://localhost:5000
核心依赖PackageReference Include="Microsoft.Agents.AI" Version="1.0.0-preview" />
PackageReference Include="Microsoft.Extensions.AI" Version="9.10.1-preview" />
PackageReference Include="AntDesign" Version="1.4.0" />
PackageReference Include="SqlSugar" Version="5.1.4" />
PackageReference Include="Markdig" Version="0.37.0" />
代码仓库
GitHub: https://github.com/xuzeyu91/BlogAgent
写在最后：
这篇文章本身，就是用BlogAgent生成初稿，然后人工润色完成的。效率提升了至少3倍。
如果你觉得这个项目有意思，欢迎Star⭐支持。有问题可以提Issue，咱们一起把Agent玩明白。
Happy Coding!
来源：opendotnet
免责声明：本站系转载，并不代表本网赞同其观点和对其真实性负责。如涉及作品内容、版权和其它问题，请在30日内与本站联系，我们将在第一时间删除内容!