Semantic Kernel — 微软企业级 Agent 开发框架

GitHub: microsoft/semantic-kernel
Stars: 28,100+ | Language: C# (66.7%), Python (31.4%) | License: MIT
官网: learn.microsoft.com/semantic-kernel

目录

1. 项目速览
2. 功能概述
3. 适用场景
4. 快速上手
5. 源码架构
6. 实操 Demo
7. 同类对比
8. 参考资源

项目速览

Semantic Kernel（简称 SK）是微软于 2023 年初开源的企业级 AI Agent 开发框架，定位为 “Model-agnostic SDK that empowers developers to build, orchestrate, and deploy AI agents and multi-agent systems”。截至 2026 年 6 月，项目在 GitHub 上已获得超过 28,100 颗 Star，是微软在 AI Agent 领域投入最大的开源项目之一。

Semantic Kernel 的核心理念是将企业级 AI 能力嵌入现有应用架构。不同于 LangChain 等以 Python 生态为中心的框架，SK 同时提供 .NET、Python 和 Java 三种语言的 SDK，其中 .NET 版本是主力。设计上强调与微软生态（Azure AI、Microsoft 365、Power Platform）的深度集成，以及企业应用所需的治理能力（安全、合规、可观测性）。

2025 年是 SK 的关键转型年。微软推出了 Agent Framework（Agent 框架），将 SK 从 LLM 编排引擎升级为完整的 Agent 开发平台。同时，微软宣布 SK 正在与 AutoGen（微软研究院的多 Agent 研究框架）融合，基于共享运行时构建统一的 Agent 解决方案。值得注意的是，微软还发布了 **Microsoft Agent Framework (MAF)**，定位为 SK 的企业级继任者，但目前 SK 仍然是生产级应用中推荐使用的主要 SDK。

功能概述

Agent Framework — 多 Agent 协作核心

SK Agent Framework 是 2025 年的旗舰功能，提供面向自主、目标驱动的 Agent 应用开发的完整抽象：

• Agent 类：构建独立 Agent 的基础类，每个 Agent 拥有专属的技能（Skills）和知识
• Agent Chat：管理单个 Agent 与 AI 及 API 端点之间的交互
• Agent Group Chat：动态多 Agent 协调——参与 Agent 可以在运行时动态加入和退出对话
• Service-Managed Threads：通过 Azure AI 自动管理对话历史，无需手动追踪消息
• Human-in-the-Loop：原生支持 ctx.request_info() 在关键决策点暂停工作流，等待人工审批

Agent 之间通过 Structured Output Routing 实现动态编排：每个 Agent 返回 Pydantic 模型（Python）或强类型对象（.NET），包含 next_agent 路由决策，实现灵活的动态工作流。

Planner 规划系统

Planner 是 SK 的核心组件之一，允许 AI 将自然语言目标自动分解为可执行步骤。SK 提供多种 Planner：

• Sequential Planner：按预定义顺序线性执行步骤
• Action Planner：为目标选择单个最佳操作
• Stepwise Planner：迭代式规划和执行，根据中间结果动态调整
• Handlebars Planner：使用 Handlebars 模板引擎生成执行计划，适合需要确定性和可预测性的场景
• Dynamic Planning：AI 在运行时决定执行路径，根据上下文和结果实时添加新步骤

Planner 与智能路由图（Intelligent Routing Graphs）协同工作，将可能的决策路径表示为有向图，允许 Agent 根据实时条件沿不同路径执行。

Process Framework — 长业务流程编排

对于需要持续数小时甚至数天的企业级业务流程，SK 提供了 Process Framework：

• 事件驱动架构：步骤之间通过事件通信，天然支持异步并行执行和扇出（fan-out）模式
• 分布式编排：与 Dapr 和 Microsoft Orleans 集成，支持跨服务的分布式工作流
• 持久化状态：业务流程状态可持久化，支持故障恢复和长时间暂停
• Agent 嵌入：Process 的每个步骤可以是一个普通函数，也可以是一个完整的 Agent

多语言 SDK 与模型无关

SK 的独特优势之一是真正的多语言支持和模型无关设计：

• .NET SDK（主力）：与 ASP.NET Core、Azure Functions、Blazor 等微软技术栈无缝集成
• Python SDK：与 FastAPI、Flask 等 Python 框架兼容，已被广泛采用（占仓库代码 31.4%）
• Java SDK：支持 Spring Boot 等 Java 生态
• 模型支持：OpenAI、Azure OpenAI、Hugging Face、NVIDIA NIM、Ollama、LMStudio 等
• 向量数据库：Azure AI Search、Elasticsearch、Chroma、Pinecone 等多种选择

AutoGen 融合

2025 年微软启动了一项重大整合计划：将 SK 与 AutoGen 多 Agent 研究框架融合在共享运行时上：

• 共享运行时：统一 Agent 编排抽象，可进程内托管或分布式部署（Dapr、Orleans）
• 互操作性：AutoGen Agent 可以托管在 SK 中运行（SK Python 1.20.0+ 已支持）
• 连接器共享：AutoGen 可以复用 SK 的 AI 连接器库（Anthropic、Ollama、Gemini、Azure Foundry 等）
• AutoGen Studio：无代码 GUI，拖拽构建 Agent 团队，底层使用声明式 JSON 配置

企业级治理

Semantic Kernel 从设计之初就面向企业场景，提供精细的安全与合规控制：

• Azure 托管身份：支持 Managed Identity 进行服务间认证
• 敏感数据处理：通过 Filters 和 Middleware 实现 PII 检测和脱敏
• 审计追踪：与 Azure Monitor / Application Insights 集成，完整记录 Agent 行为
• 响应过滤：可配置的内容安全过滤器，防止不当输出

适用场景

.NET 技术栈的 AI 应用集成

SK 是 .NET 生态中最成熟、微软官方支持的 Agent 框架。如果你的团队使用 C# 和 .NET（ASP.NET Core、Blazor、MAUI 等），SK 是嵌入 AI 能力最自然的选择。它提供了 .NET 原生的依赖注入、配置管理和中间件管道，与现有企业应用架构无缝兼容。

企业业务流程自动化

结合 Process Framework 和 Planner，SK 可以自动化复杂的业务流程：订单处理（验证→库存检查→支付→通知）、合同审批（解析→风险评估→合规检查→人工审批）、IT 运维（告警分析→诊断→修复→报告）等。Dapr/Orleans 集成使其能够横向扩展以处理大规模工作负载。

Microsoft 365 与 Azure 生态集成

SK 可以原生访问 Microsoft Graph API（邮件、日历、联系人、文件等）、Azure AI Services（认知服务、机器翻译、文档智能等）和 Power Platform。这使得构建”AI 驱动的企业助手”变得非常简单——Agent 可以读取邮件、创建日历事件、查询 SharePoint 文档、调用 Azure AI 能力。

RAG 知识管理

SK 提供完整的 RAG 支持，结合 Azure AI Search 作为矢量存储后端。适用于企业内部知识库问答、技术文档搜索、合规政策查询等场景。与传统 RAG 不同，SK 的 Agent Framework 允许构建自我纠错的多 Agent 网络，提升 RAG 结果的可靠性。

多 Agent 系统研究与原型

由于 SK 正在与 AutoGen 融合，它既可以用于生产部署（通过 SK），也可以用于 Agent 行为研究和原型开发（通过 AutoGen Studio 的可视化拖拽界面）。这使得团队可以在同一生态内完成从实验到上线的全过程。

快速上手

安装（Python）

pip install semantic-kernel

如需使用 Azure AI 服务管理线程（Agent Framework）：

pip install semantic-kernel[azure]

安装（.NET）

dotnet add package Microsoft.SemanticKernel

最简示例（Python）：创建插件并使用 Planner

import asyncio
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.functions import kernel_function
from semantic_kernel.planners import SequentialPlanner


# 定义一个自定义插件
class TimePlugin:
    """时间相关工具插件"""

    @kernel_function(
        name="get_current_time",
        description="获取当前的日期和时间"
    )
    def get_current_time(self) -> str:
        from datetime import datetime
        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    @kernel_function(
        name="days_until",
        description="计算距离目标日期还有多少天"
    )
    def days_until(self, target_date: str) -> str:
        from datetime import datetime
        target = datetime.strptime(target_date, "%Y-%m-%d")
        delta = target - datetime.now()
        return f"距离 {target_date} 还有 {delta.days} 天"


async def main():
    # 初始化 Kernel
    kernel = Kernel()

    # 添加 AI 服务
    kernel.add_service(
        OpenAIChatCompletion(
            service_id="gpt4",
            api_key="sk-...",  # 替换为你的 API Key
            ai_model_id="gpt-4o",
        )
    )

    # 注册插件
    kernel.add_plugin(TimePlugin(), plugin_name="TimePlugin")

    # 使用 Planner 自动规划任务
    planner = SequentialPlanner(kernel)
    plan = await planner.create_plan(
        "告诉我现在的日期和时间，然后计算距离 2027 年元旦还有多少天"
    )

    print(f"执行计划：{plan.name}")
    result = await plan.invoke(kernel)
    print(f"结果：\n{result}")


if __name__ == "__main__":
    asyncio.run(main())

源码架构

Semantic Kernel 采用多语言 monorepo 结构：

semantic-kernel/
├── dotnet/                              # .NET SDK（主力实现）
│   ├── src/
│   │   ├── SemanticKernel.Core/         #   核心抽象：Kernel、Function、Plugin
│   │   ├── SemanticKernel.Abstractions/ #   公共接口和契约
│   │   ├── SemanticKernel.Agents/       #   Agent Framework 实现
│   │   ├── SemanticKernel.Planners/     #   Planner 系统（Sequential、Stepwise 等）
│   │   ├── SemanticKernel.Process/      #   Process Framework（长业务流程）
│   │   ├── SemanticKernel.Connectors/   #   AI 连接器（OpenAI、Azure、Ollama 等）
│   │   └── SemanticKernel.Memory/       #   记忆与向量存储集成
│   └── samples/                         #   .NET 示例项目
├── python/                              # Python SDK
│   ├── semantic_kernel/
│   │   ├── kernel.py                    #   Kernel 核心类
│   │   ├── functions/                   #   函数与插件系统
│   │   ├── connectors/                  #   AI 连接器
│   │   ├── agents/                      #   Agent Framework
│   │   ├── planners/                    #   Planner 实现
│   │   ├── processes/                   #   Process Framework
│   │   └── memory/                      #   记忆系统
│   └── samples/                         #   Python 示例
├── java/                                # Java SDK
│   ├── semantickernel-api/              #   Java API 模块
│   └── samples/                         #   Java 示例
├── prompt_template_samples/             # 提示词模板示例
└── docs/                                # 文档站点

• **dotnet/src/SemanticKernel.Core/**：.NET SDK 的核心，实现 Kernel 抽象、函数注册管道、插件系统和依赖注入集成。
• **dotnet/src/SemanticKernel.Agents/**：Agent Framework 的 .NET 实现，包含 Agent、Agent Chat、Agent Group Chat 和服务管理线程等核心抽象。
• **dotnet/src/SemanticKernel.Planners/**：Planner 系统实现，支持 Sequential、Stepwise、Handlebars 等多种规划策略。
• **dotnet/src/SemanticKernel.Process/**：Process Framework，事件驱动的长业务流程编排引擎，集成 Dapr/Orleans 分布式运行时。
• **python/semantic_kernel/**：Python SDK，功能与 .NET 版本基本对等，额外支持与 AutoGen 的互操作性。

实操 Demo

下面是一个完整的 Agent 插件系统 Demo，展示如何创建自定义技能并使用 Planner 自动编排。

"""
Semantic Kernel 完整 Agent Demo
功能：自定义插件 + 多技能组合 + Planner 自动编排
"""

import asyncio
from typing import Annotated
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.functions import kernel_function
from semantic_kernel.contents import ChatHistory
from semantic_kernel.planners import FunctionCallingStepwisePlanner
from semantic_kernel.planners.function_calling_stepwise_planner_options import (
    FunctionCallingStepwisePlannerOptions,
)


# ===================== 自定义插件 1：邮件管理 =====================

class EmailPlugin:
    """企业邮件管理插件"""

    def __init__(self):
        # 模拟邮件数据（生产环境应连接 Exchange/Graph API）
        self.inbox = [
            {"id": 1, "from": "ceo@company.com", "subject": "Q3 战略会议安排", "body": "请各事业部负责人在周五前提交 Q3 规划初稿。", "read": False},
            {"id": 2, "from": "hr@company.com", "subject": "年度绩效考核通知", "body": "2026 年度绩效考核将于下周一启动，请按时完成自评。", "read": False},
            {"id": 3, "from": "it@company.com", "subject": "安全更新通知", "body": "所有员工需在本周内完成安全培训课程。", "read": True},
            {"id": 4, "from": "partner@client.com", "subject": "项目交付确认", "body": "请确认 Phase 2 的交付时间是否可提前至 7 月 15 日。", "read": False},
        ]

    @kernel_function(
        name="get_unread_emails",
        description="获取所有未读邮件，返回发件人、主题和正文摘要"
    )
    def get_unread_emails(self) -> str:
        unread = [e for e in self.inbox if not e["read"]]
        if not unread:
            return "没有未读邮件。"

        result_lines = []
        for i, email in enumerate(unread, 1):
            result_lines.append(
                f"{i}. 发件人: {email['from']} | 主题: {email['subject']} | 摘要: {email['body'][:50]}..."
            )
        return "\n".join(result_lines)

    @kernel_function(
        name="search_emails",
        description="根据关键词搜索邮件，返回匹配的邮件列表"
    )
    def search_emails(self, keyword: Annotated[str, "搜索关键词"]) -> str:
        matches = [e for e in self.inbox if keyword.lower() in e["subject"].lower() or keyword.lower() in e["body"].lower()]
        if not matches:
            return f"未找到包含 '{keyword}' 的邮件。"

        result_lines = []
        for email in matches[:5]:  # 最多返回 5 条
            result_lines.append(
                f"- [{email['from']}] {email['subject']}: {email['body'][:80]}..."
            )
        return "\n".join(result_lines)


# ===================== 自定义插件 2：任务管理 =====================

class TaskPlugin:
    """任务管理插件"""

    def __init__(self):
        self.tasks = [
            {"id": 1, "title": "完成 Q3 规划初稿", "priority": "高", "deadline": "2026-06-20", "status": "进行中"},
            {"id": 2, "title": "安全培训课程", "priority": "中", "deadline": "2026-06-18", "status": "未开始"},
            {"id": 3, "title": "年度绩效自评", "priority": "高", "deadline": "2026-06-23", "status": "未开始"},
            {"id": 4, "title": "确认 Phase 2 交付时间", "priority": "高", "deadline": "2026-06-16", "status": "未开始"},
        ]

    @kernel_function(
        name="get_pending_tasks",
        description="获取所有待办任务，按优先级排序"
    )
    def get_pending_tasks(self) -> str:
        priority_order = {"高": 0, "中": 1, "低": 2}
        pending = sorted(
            [t for t in self.tasks if t["status"] != "已完成"],
            key=lambda x: priority_order.get(x["priority"], 2)
        )

        result_lines = []
        for task in pending:
            result_lines.append(
                f"- [{task['priority']}优先级] {task['title']} (截止: {task['deadline']}, 状态: {task['status']})"
            )
        return "\n".join(result_lines)

    @kernel_function(
        name="create_task",
        description="创建新任务"
    )
    def create_task(
        self,
        title: Annotated[str, "任务标题"],
        priority: Annotated[str, "优先级（高/中/低）"],
        deadline: Annotated[str, "截止日期 YYYY-MM-DD"],
    ) -> str:
        new_task = {
            "id": len(self.tasks) + 1,
            "title": title,
            "priority": priority,
            "deadline": deadline,
            "status": "未开始",
        }
        self.tasks.append(new_task)
        return f"任务已创建: [{priority}] {title} (截止: {deadline})"


# ===================== 自定义插件 3：日程分析 =====================

class SchedulePlugin:
    """日程分析与建议插件"""

    @kernel_function(
        name="analyze_workload",
        description="分析当前工作负载，识别冲突和风险，给出优先级建议"
    )
    def analyze_workload(self, tasks_summary: Annotated[str, "待办任务摘要"]) -> str:
        """基于任务摘要分析工作负载"""
        analysis = f"""## 工作负载分析

基于当前任务情况的建议：

1. **紧急事项**：确认客户交付时间（截止日期最近，需要立即回复）
2. **高优先级**：Q3 规划初稿和绩效自评，建议每天分配 1 小时专注处理
3. **可延后**：安全培训可在完成紧急事项后处理

建议今日行动：
- 上午：回复客户邮件确认交付时间
- 下午：起草 Q3 规划框架
- 明日：开始绩效自评 + 完成安全培训
"""
        return analysis


# ===================== 主流程 =====================

async def main():
    print("=" * 60)
    print("  Semantic Kernel Agent Demo")
    print("  智能邮件处理 + 任务管理 + 日程分析")
    print("=" * 60)

    # 初始化 Kernel
    kernel = Kernel()

    # 添加 AI 服务
    kernel.add_service(
        OpenAIChatCompletion(
            service_id="gpt4",
            api_key="sk-...",  # 替换为你的 API Key
            ai_model_id="gpt-4o",
        )
    )

    # 注册插件
    kernel.add_plugin(EmailPlugin(), plugin_name="EmailPlugin")
    kernel.add_plugin(TaskPlugin(), plugin_name="TaskPlugin")
    kernel.add_plugin(SchedulePlugin(), plugin_name="SchedulePlugin")

    # 使用 FunctionCallingStepwisePlanner 执行复杂任务
    print("\n[配置] 使用 FunctionCallingStepwisePlanner...")

    planner_options = FunctionCallingStepwisePlannerOptions(
        max_iterations=10,   # 最多 10 步迭代
        max_tokens=4000,     # 每步最多 4000 token
    )
    planner = FunctionCallingStepwisePlanner(
        kernel=kernel,
        options=planner_options,
    )

    # 定义任务
    goal = """
    请帮我完成以下工作：
    1. 检查未读邮件
    2. 查看所有待办任务
    3. 基于邮件内容和待办任务，分析我的工作负载并给出今日行动建议
    4. 如果邮件中有需要创建新任务的，自动创建
    """

    print(f"\n[任务] {goal.strip()}")
    print("\n[执行过程]")

    result = await planner.invoke(kernel, goal)

    print("\n" + "=" * 60)
    print("  [最终结果]")
    print("=" * 60)
    print(result)


if __name__ == "__main__":
    asyncio.run(main())

运行：

pip install semantic-kernel
export OPENAI_API_KEY="sk-..."
python sk_agent_demo.py

同类对比

特性	Semantic Kernel	LangChain	OpenAI Agents SDK
定位	企业级多语言 Agent SDK	通用 Agent 工程平台	OpenAI 官方 Agent 框架
Stars	28,100+	139,000+	25,000+
支持语言	C# / Python / Java	Python（主力）	Python
核心优势	微软生态深度集成（Azure/M365），.NET 原生支持，企业级治理	生态最丰富，LangGraph 编排灵活，社区活跃度最高	与 OpenAI 模型最佳配合，API 设计简洁现代
Agent 模式	Agent Framework + Planner + Process Framework	create_agent + LangGraph + Middleware	Agent + Handoff + Guardrails
企业功能	Azure 集成、DI 支持、审计追踪、响应过滤	通过 LangSmith 和合作伙伴提供	OpenAI 平台内置监控和安全
适用场景	.NET 技术栈企业应用、Azure 生态、需要多语言支持的项目	需要最大灵活性和集成选择的通用 Agent 应用	深度依赖 OpenAI 模型的简单 Agent 应用

分析：Semantic Kernel 的最大差异化优势在于企业就绪性和多语言支持。如果你的技术栈是 C#/.NET 或 Java，SK 几乎是唯一成熟的官方选择。与 LangChain 相比，SK 的生态不如 LangChain 丰富，但其与微软企业生态（Azure AI、Microsoft 365、Power Platform）的深度集成在特定场景中不可替代。OpenAI Agents SDK 更简洁轻量，但深度绑定 OpenAI 模型，缺乏其他提供商的灵活性。值得关注的是，微软正推动 SK 与 AutoGen 融合，未来有望将生产级稳定性和前沿研究能力统一到一个平台中。

参考资源

• 官方文档: https://learn.microsoft.com/en-us/semantic-kernel/
• GitHub 仓库: https://github.com/microsoft/semantic-kernel
• Microsoft Agent Framework: https://devblogs.microsoft.com/agent-framework/
• AutoGen 项目: https://github.com/microsoft/autogen
• SK + AutoGen 融合博客: https://devblogs.microsoft.com/agent-framework/semantic-kernel-and-autogen-part-2/
• 社区 Discord: https://aka.ms/sk/discord