Semantic Kernel
Semantic Kernel 是微软推出的轻量级 SDK，旨在让开发者轻松地将 LLM 与传统编程语言结合。它采用"技能"（Skills）和"规划器"（Planner）的设计，特别适合企业级应用开发。
一、核心原理
1.1 设计哲学
Semantic Kernel 的设计理念是"语义代码融合"：
┌─────────────────────────────────────────────────────────────┐
│ Semantic Kernel 设计哲学 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 核心理念：让 AI 与代码无缝协作 │
│ │
│ 传统开发： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 程序员编写代码 → 编译执行 → 输出结果 │ │
│ │ （代码逻辑固定，无法灵活应对变化） │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ Semantic Kernel： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌───────────┐ ┌───────────┐ │ │
│ │ │ 自然语言 │ │ 传统代码 │ │ │
│ │ │ (Ask) │ │ (Code) │ │ │
│ │ └─────┬─────┘ └─────┬─────┘ │ │
│ │ │ │ │ │
│ │ └────────┬────────┘ │ │
│ │ │ │ │
│ │ ↓ │ │
│ │ ┌───────────────┐ │ │
│ │ │ Kernel │ │ │
│ │ │ (语义内核) │ │ │
│ │ └───────┬───────┘ │ │
│ │ │ │ │
│ │ ┌───────┴───────┐ │ │
│ │ ↓ ↓ │ │
│ │ ┌──────────┐ ┌──────────┐ │ │
│ │ │ Skills │ │ Planner │ │ │
│ │ │ 技能库 │ │ 规划器 │ │ │
│ │ └──────────┘ └──────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 优势： │
│ • AI 理解自然语言意图 │
│ • 自动组合技能完成任务 │
│ • 代码和 AI 无缝协作 │
│ │
└─────────────────────────────────────────────────────────────┘1.2 核心概念
| 概念 | 英文 | 作用 | 类比 |
|---|---|---|---|
| Kernel | 内核 | 管理所有组件的容器 | 操作系统 |
| Skill | 技能 | 可被 AI 调用的功能单元 | 函数/方法 |
| Planner | 规划器 | 将目标分解为技能调用序列 | 编排引擎 |
| Memory | 记忆 | 存储上下文和嵌入向量 | 数据库 |
| Connector | 连接器 | 连接外部 AI 服务和 API | 适配器 |
1.3 架构图
┌─────────────────────────────────────────────────────────────┐
│ Semantic Kernel 架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 应用层 │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ Copilot │ │ Chatbot │ │ Workflow │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Semantic Kernel (SDK) │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ Kernel Core │ │ │
│ │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │
│ │ │ │ Skills │ │ Planner │ │ Memory │ │ │ │
│ │ │ │ Manager │ │ Manager │ │ Manager │ │ │ │
│ │ │ └─────────┘ └─────────┘ └─────────┘ │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ Connectors │ │ │
│ │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │
│ │ │ │OpenAI │ │ Azure │ │ Hugging │ │ │ │
│ │ │ │Connector│ │ OpenAI │ │ Face │ │ │ │
│ │ │ └─────────┘ └─────────┘ └─────────┘ │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 外部服务 & 数据源 │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ OpenAI │ │ Azure │ │ Database │ │ │
│ │ │ API │ │ Services │ │ Storage │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘二、核心组件详解
2.1 Kernel（内核）
Kernel 是 Semantic Kernel 的核心容器：
"""
Semantic Kernel 初始化示例
Python 版本
"""
import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import (
OpenAIChatCompletion,
OpenAITextEmbedding
)
# ========== 1. 创建 Kernel ==========
def create_kernel():
"""创建基础 Kernel"""
kernel = sk.Kernel()
# 配置 AI 服务
api_key = "your-openai-api-key"
# 添加聊天模型
kernel.add_chat_service(
"chat-gpt",
OpenAIChatCompletion(
model_id="gpt-4",
api_key=api_key
)
)
# 添加嵌入模型
kernel.add_text_embedding_generation_service(
"embedding",
OpenAITextEmbedding(
model_id="text-embedding-ada-002",
api_key=api_key
)
)
return kernel
# ========== 2. 配置多模型 ==========
def configure_multi_model():
"""配置多模型 Kernel"""
kernel = sk.Kernel()
# 主力模型：GPT-4
kernel.add_chat_service(
"gpt4",
OpenAIChatCompletion(model_id="gpt-4", api_key="...")
)
# 快速模型：GPT-3.5
kernel.add_chat_service(
"gpt35",
OpenAIChatCompletion(model_id="gpt-3.5-turbo", api_key="...")
)
# 不同模型用于不同场景
# gpt4 用于复杂推理
# gpt35 用于快速响应
return kernel
# ========== 3. 使用 Azure OpenAI ==========
def create_azure_kernel():
"""使用 Azure OpenAI"""
kernel = sk.Kernel()
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
kernel.add_chat_service(
"azure-gpt4",
AzureChatCompletion(
deployment_name="gpt-4-deployment",
endpoint="https://your-resource.openai.azure.com/",
api_key="your-azure-api-key",
api_version="2024-02-15-preview"
)
)
return kernel2.2 Skills（技能）
Skills 是 Semantic Kernel 的核心概念，分为两类：
┌─────────────────────────────────────────────────────────────┐
│ Skills 类型 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Semantic Skills (语义技能) │ │
│ │ │ │
│ │ 特点：使用自然语言定义，由 LLM 执行 │ │
│ │ │ │
│ │ 示例： │ │
│ │ • SummarizeSkill: "总结以下文本" │ │
│ │ • TranslateSkill: "将文本翻译成中文" │ │
│ │ • QASkill: "回答问题" │ │
│ │ │ │
│ │ 实现：Prompt Template │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Native Skills (原生技能) │ │
│ │ │ │
│ │ 特点：使用编程语言实现，执行确定性行为 │ │
│ │ │ │
│ │ 示例： │ │
│ │ • FileSkill: 文件读写 │ │
│ │ • HttpSkill: HTTP 请求 │ │
│ │ • MathSkill: 数学计算 │ │
│ │ • TimeSkill: 时间操作 │ │
│ │ │ │
│ │ 实现：Python/C# 函数 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 两者协作： │
│ Semantic Skills ←→ Native Skills │
│ AI 能力 代码能力 │
│ ↘ ↙ │
│ 组合完成复杂任务 │
│ │
└─────────────────────────────────────────────────────────────┘代码示例：
"""
Semantic Kernel Skills 示例
"""
from semantic_kernel.skill_definition import sk_function, sk_function_context_parameter
from semantic_kernel.orchestration.sk_context import SKContext
# ========== 1. Native Skills (原生技能) ==========
class MathSkills:
"""数学计算技能"""
@sk_function(
description="计算两个数的和",
name="add"
)
@sk_function_context_parameter(
name="a",
description="第一个数字"
)
@sk_function_context_parameter(
name="b",
description="第二个数字"
)
def add(self, context: SKContext) -> str:
a = float(context["a"])
b = float(context["b"])
return str(a + b)
@sk_function(
description="计算两个数的乘积",
name="multiply"
)
def multiply(self, context: SKContext) -> str:
a = float(context["a"])
b = float(context["b"])
return str(a * b)
@sk_function(
description="计算平方根",
name="sqrt"
)
def sqrt(self, context: SKContext) -> str:
import math
n = float(context["input"])
return str(math.sqrt(n))
class TimeSkills:
"""时间操作技能"""
@sk_function(
description="获取当前时间",
name="now"
)
def now(self) -> str:
from datetime import datetime
return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
@sk_function(
description="获取当前日期",
name="today"
)
def today(self) -> str:
from datetime import datetime
return datetime.now().strftime("%Y-%m-%d")
@sk_function(
description="计算日期差",
name="date_diff"
)
def date_diff(self, context: SKContext) -> str:
from datetime import datetime
date1 = datetime.strptime(context["date1"], "%Y-%m-%d")
date2 = datetime.strptime(context["date2"], "%Y-%m-%d")
delta = abs((date2 - date1).days)
return str(delta)
class FileSkills:
"""文件操作技能"""
@sk_function(
description="读取文件内容",
name="read"
)
def read(self, context: SKContext) -> str:
filepath = context["filepath"]
try:
with open(filepath, 'r', encoding='utf-8') as f:
return f.read()
except Exception as e:
return f"读取错误: {str(e)}"
@sk_function(
description="写入文件",
name="write"
)
def write(self, context: SKContext) -> str:
filepath = context["filepath"]
content = context["content"]
try:
with open(filepath, 'w', encoding='utf-8') as f:
f.write(content)
return "写入成功"
except Exception as e:
return f"写入错误: {str(e)}"
# ========== 2. Semantic Skills (语义技能) ==========
# 语义技能通过 Prompt Template 定义
# 存储在 skills/ 目录下的 .txt 或 .json 文件中
# 示例：skills/SummarizeSkill/skill.txt
SUMMARIZE_PROMPT = """
请总结以下文本的要点：
{{$input}}
总结：
"""
# 示例：skills/TranslateSkill/skill.txt
TRANSLATE_PROMPT = """
将以下文本翻译成 {{$language}}：
{{$input}}
翻译结果：
"""
# ========== 3. 注册和使用技能 ==========
async def register_and_use_skills():
"""注册和使用技能"""
kernel = create_kernel()
# 注册原生技能
kernel.import_skill(MathSkills(), skill_name="math")
kernel.import_skill(TimeSkills(), skill_name="time")
kernel.import_skill(FileSkills(), skill_name="file")
# 注册语义技能
# kernel.import_semantic_skill_from_directory("./skills", "SummarizeSkill")
# 使用原生技能
math_skill = kernel.skills.get_function("math", "add")
context = kernel.create_new_context()
context["a"] = "10"
context["b"] = "20"
result = await kernel.run_async(math_skill, input_vars=context.variables)
print(f"10 + 20 = {result}") # 输出: 30
# 使用时间技能
time_skill = kernel.skills.get_function("time", "now")
result = await kernel.run_async(time_skill)
print(f"当前时间: {result}")2.3 Planner（规划器）
Planner 是 Semantic Kernel 的核心特性，负责将用户意图转化为技能调用序列：
┌─────────────────────────────────────────────────────────────┐
│ Planner 工作流程 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 用户请求： │
│ "今天是什么日期？计算今天到 2024-12-31 的天数差" │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Planner │ │
│ │ │ │
│ │ 1. 分析请求： │ │
│ │ • 需要获取当前日期 │ │
│ │ • 需要计算日期差 │ │
│ │ │ │
│ │ 2. 匹配技能： │ │
│ │ • time.today → 获取当前日期 │ │
│ │ • time.date_diff → 计算日期差 │ │
│ │ │ │
│ │ 3. 生成计划： │ │
│ │ Step 1: result_1 = time.today() │ │
│ │ Step 2: result_2 = time.date_diff( │ │
│ │ date1=result_1, │ │
│ │ date2="2024-12-31" │ │
│ │ ) │ │
│ │ Step 3: return result_2 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 执行计划 │ │
│ │ │ │
│ │ Step 1: time.today() │ │
│ │ → "2024-03-15" │ │
│ │ │ │
│ │ Step 2: time.date_diff("2024-03-15", "2024-12-31") │ │
│ │ → "291" │ │
│ │ │ │
│ │ 结果：距离 2024-12-31 还有 291 天 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘代码示例：
"""
Semantic Kernel Planner 示例
"""
from semantic_kernel.planning import (
SequentialPlanner,
ActionPlanner,
StepwisePlanner
)
# ========== 1. Sequential Planner ==========
async def sequential_planner_example(kernel):
"""
Sequential Planner
生成线性执行的计划
"""
# 导入技能
kernel.import_skill(MathSkills(), skill_name="math")
kernel.import_skill(TimeSkills(), skill_name="time")
# 创建规划器
planner = SequentialPlanner(kernel)
# 生成计划
plan = await planner.create_plan(
"计算 10 加 20 的结果，然后计算这个结果的平方根"
)
# 执行计划
result = await plan.invoke_async()
print(f"结果: {result}")
# 查看计划步骤
print("\n计划步骤:")
for step in plan.steps:
print(f" - {step.description}")
# ========== 2. Action Planner ==========
async def action_planner_example(kernel):
"""
Action Planner
选择最合适的单个技能执行
"""
planner = ActionPlanner(kernel)
# 分析并选择最佳技能
plan = await planner.create_plan(
"告诉我现在是什么时间"
)
result = await plan.invoke_async()
print(f"结果: {result}")
# ========== 3. Stepwise Planner ==========
async def stepwise_planner_example(kernel):
"""
Stepwise Planner
逐步执行，支持条件判断和循环
"""
planner = StepwisePlanner(kernel)
plan = await planner.create_plan(
"帮我分析当前日期，计算距离年底还有多少天"
)
result = await plan.invoke_async()
print(f"结果: {result}")
# ========== 4. 自定义 Planner ==========
class CustomPlanner:
"""
自定义规划器
可以实现特定的规划逻辑
"""
def __init__(self, kernel):
self.kernel = kernel
async def create_plan(self, goal: str):
"""
创建自定义计划
Args:
goal: 用户目标
Returns:
执行计划
"""
# 1. 分析目标
analysis = await self._analyze_goal(goal)
# 2. 选择技能
skills = self._select_skills(analysis)
# 3. 排序技能
ordered = self._order_skills(skills)
# 4. 创建计划
plan = self._build_plan(ordered)
return plan
async def _analyze_goal(self, goal):
"""分析目标"""
# 使用 LLM 分析目标
# 返回需要的操作类型
pass
def _select_skills(self, analysis):
"""选择技能"""
# 根据分析结果选择合适的技能
pass
def _order_skills(self, skills):
"""排序技能"""
# 确定执行顺序
pass
def _build_plan(self, skills):
"""构建计划"""
# 创建执行计划
pass2.4 Memory（记忆）
"""
Semantic Kernel Memory 示例
"""
from semantic_kernel.memory.semantic_text_memory import SemanticTextMemory
from semantic_kernel.memory.volatile_memory_store import VolatileMemoryStore
# ========== 1. 基础记忆 ==========
async def basic_memory_example(kernel):
"""基础记忆使用"""
# 创建记忆存储
memory = SemanticTextMemory(
storage=VolatileMemoryStore(),
embeddings_generator=kernel.get_ai_service("embedding")
)
# 保存信息
await memory.save_information_async(
collection="my_knowledge",
text="Python 是一种高级编程语言",
id="python_intro"
)
await memory.save_information_async(
collection="my_knowledge",
text="机器学习是 AI 的一个分支",
id="ml_intro"
)
# 检索相关信息
results = await memory.search_async(
collection="my_knowledge",
query="什么是 AI",
limit=3
)
for result in results:
print(f"- {result.text} (相关度: {result.relevance})")
# ========== 2. 持久化记忆 ==========
async def persistent_memory_example(kernel):
"""持久化记忆"""
from semantic_kernel.connectors.memory.chroma import ChromaMemoryStore
# 使用 Chroma 作为持久化存储
memory = SemanticTextMemory(
storage=ChromaMemoryStore(persist_directory="./chroma_db"),
embeddings_generator=kernel.get_ai_service("embedding")
)
# 保存和检索...三、与 LangChain 对比
┌─────────────────────────────────────────────────────────────┐
│ Semantic Kernel vs LangChain │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 设计理念 │ │
│ ├─────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ Semantic Kernel: │ │
│ │ • 代码优先，轻量级 SDK │ │
│ │ • 强调技能组合和规划 │ │
│ │ • 微软生态，Azure 集成 │ │
│ │ │ │
│ │ LangChain: │ │
│ │ • LLM 优先，功能丰富 │ │
│ │ • 强调链式调用和 Agent │ │
│ │ • 社区驱动，生态广泛 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 功能对比 │ │
│ ├─────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 特性 │ Semantic Kernel │ LangChain │ │
│ │ ────────────────────┼─────────────────┼────────────│ │
│ │ 技能/工具管理 │ Skills │ Tools │ │
│ │ 自动规划 │ Planner │ Agent │ │
│ │ 记忆系统 │ Memory │ Memory │ │
│ │ 模板引擎 │ 内置 │ PromptTemplate │
│ │ 向量存储 │ 连接器 │ 集成 │ │
│ │ 流式输出 │ 支持 │ 支持 │ │
│ │ 多语言支持 │ C#, Python │ Python, JS │ │
│ │ Azure 集成 │ 原生 │ 需配置 │ │
│ │ 社区规模 │ 较小 │ 大 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 适用场景： │
│ • 企业级 .NET 应用 → Semantic Kernel │
│ • Azure 云服务集成 → Semantic Kernel │
│ • Python 生态项目 → LangChain │
│ • 快速原型开发 → LangChain │
│ │
└─────────────────────────────────────────────────────────────┘四、面试问答
Q1: Semantic Kernel 的核心组件有哪些？
回答要点：
- Kernel：核心容器，管理所有组件
- Skills：技能，分为 Semantic Skills（语义）和 Native Skills（原生）
- Planner：规划器，自动组合技能完成任务
- Memory：记忆系统，存储上下文和向量
- Connectors：连接器，连接外部 AI 服务
Q2: Semantic Skills 和 Native Skills 有什么区别？
回答要点：
| 对比维度 | Semantic Skills | Native Skills |
|---|---|---|
| 定义方式 | 自然语言 Prompt | 编程语言函数 |
| 执行方式 | LLM 执行 | 代码直接执行 |
| 确定性 | 不确定 | 确定 |
| 适用场景 | 语义理解、生成 | 计算、IO 操作 |
Q3: Planner 如何选择和组合技能？
回答要点：
- 分析用户意图：理解用户想要什么
- 匹配可用技能：从技能库中找到相关技能
- 生成执行计划：确定技能调用顺序和参数传递
- 执行计划：按顺序执行各步骤
Q4: Semantic Kernel 与微软 Copilot 的关系？
回答要点：
- Semantic Kernel 是微软 Copilot 的底层技术之一
- Copilot 使用 SK 的技能和规划能力
- SK 为开发者提供了构建类似 Copilot 应用的能力
五、小结
Semantic Kernel 是微软的企业级 Agent 框架：
核心优势
- 轻量级 SDK：易于集成到现有代码
- 技能系统：清晰的技能定义和组合
- 自动规划：Planner 自动生成执行计划
- 微软生态：与 Azure 服务无缝集成
关键要点
- Skills 是核心：合理组织技能是关键
- Planner 是灵魂：自动规划能力体现智能
- Memory 是基础：上下文管理支撑对话
下一步学习
- 学习 框架对比与选型
- 实践 Semantic Kernel 与 Azure 服务集成
- 探索自定义 Planner 的实现