Python版Semantic Kernel完全指南：从安装到部署的完整流程-优快云博客

Python版Semantic Kernel完全指南：从安装到部署的完整流程

【免费下载链接】semantic-kernel Integrate cutting-edge LLM technology quickly and easily into your apps 项目地址: https://gitcode.com/GitHub_Trending/se/semantic-kernel

引言：为什么选择Semantic Kernel？

你是否曾经遇到过这样的困境：想要将先进的AI能力集成到应用中，却苦于复杂的集成流程和繁琐的配置？或者面对多个AI服务提供商时，不知道如何统一管理和切换？Semantic Kernel（语义内核）正是为解决这些问题而生的企业级AI编排框架。

Semantic Kernel是一个模型无关的SDK，让开发者能够快速、轻松地将前沿的LLM（Large Language Model，大语言模型）技术集成到应用中。无论你是构建简单的聊天机器人还是复杂的多智能体工作流，Semantic Kernel都提供了企业级的可靠性和灵活性。

读完本文，你将掌握：

✅ Semantic Kernel的核心概念和架构设计
✅ Python环境的完整安装和配置流程
✅ 从基础提示工程到高级智能体开发的完整技能栈
✅ 多模型集成和插件扩展的最佳实践
✅ 生产环境部署和性能优化策略
✅ 实战案例和故障排除技巧

1. 环境准备和安装

1.1 系统要求

在开始之前，请确保你的系统满足以下要求：

组件	最低要求	推荐配置
Python	3.10+	3.11+
操作系统	Windows 10+/macOS 10.15+/Linux Ubuntu 18.04+	最新稳定版
内存	4GB RAM	8GB+ RAM
存储	1GB可用空间	2GB+可用空间

1.2 基础安装

使用pip安装Semantic Kernel核心包：

# 安装核心包
pip install --upgrade semantic-kernel

# 可选：安装完整生态（包含所有可选依赖）
pip install --upgrade semantic-kernel[all]

# 或者按需安装特定组件
pip install --upgrade semantic-kernel[hugging_face]  # Hugging Face集成
pip install --upgrade semantic-kernel[azure]         # Azure服务集成
pip install --upgrade semantic-kernel[google]        # Google Cloud集成

1.3 验证安装

创建验证脚本来确认安装成功：

# verify_installation.py
import semantic_kernel as sk

def check_installation():
    print("✅ Semantic Kernel版本:", sk.__version__)
    print("✅ Python版本:", sk.__python_version__)
    print("✅ 核心模块加载成功")
    
    # 检查重要组件
    try:
        from semantic_kernel import Kernel
        from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
        from semantic_kernel.agents import ChatCompletionAgent
        print("✅ 所有核心组件可用")
        return True
    except ImportError as e:
        print("❌ 组件加载失败:", e)
        return False

if __name__ == "__main__":
    check_installation()

运行验证脚本：

python verify_installation.py

2. 核心概念解析

2.1 Semantic Kernel架构

mermaid

2.2 关键组件说明

组件	功能描述	使用场景
Kernel	核心协调器，管理服务和函数	所有应用的基础
智能体(Agent)	具备特定能力的AI实体	聊天机器人、任务执行
插件(Plugin)	可重用的功能模块	工具扩展、API集成
流程(Process)	结构化的工作流引擎	复杂业务逻辑
连接器(Connector)	AI服务适配器	多模型支持

3. 基础使用：从零开始

3.1 配置API密钥

首先设置环境变量来配置AI服务：

# 设置OpenAI API密钥
export OPENAI_API_KEY=sk-your-api-key-here
export OPENAI_MODEL_ID=gpt-4o

# 或者设置Azure OpenAI
export AZURE_OPENAI_API_KEY=your-azure-key
export AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com/
export AZURE_OPENAI_CHAT_DEPLOYMENT_NAME=your-deployment-name

或者在代码中直接配置：

# config_setup.py
import os
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()

class Config:
    # OpenAI配置
    OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
    OPENAI_MODEL = os.getenv('OPENAI_MODEL_ID', 'gpt-4o')
    
    # Azure OpenAI配置
    AZURE_API_KEY = os.getenv('AZURE_OPENAI_API_KEY')
    AZURE_ENDPOINT = os.getenv('AZURE_OPENAI_ENDPOINT')
    AZURE_DEPLOYMENT = os.getenv('AZURE_OPENAI_CHAT_DEPLOYMENT_NAME')
    
    @classmethod
    def validate(cls):
        if not cls.OPENAI_API_KEY and not cls.AZURE_API_KEY:
            raise ValueError("至少需要配置OpenAI或Azure OpenAI的API密钥")
        return True

3.2 第一个Semantic Kernel应用

创建最简单的提示工程应用：

# first_sk_app.py
import asyncio
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.functions import KernelArguments

async def basic_prompt_demo():
    """基础提示工程演示"""
    
    # 1. 创建Kernel实例
    kernel = Kernel()
    
    # 2. 添加AI服务
    kernel.add_service(OpenAIChatCompletion())
    
    # 3. 定义提示模板
    prompt_template = """
你是一个专业的技术文档编写助手。请根据以下要求生成内容：

主题：{{$topic}}
字数要求：{{$word_count}}字
风格：{{$style}}

请生成高质量的技术文档内容。
"""
    
    # 4. 设置参数并调用
    arguments = KernelArguments(
        topic="Python异步编程最佳实践",
        word_count=500,
        style="专业且易于理解"
    )
    
    # 5. 执行提示
    result = await kernel.invoke_prompt(prompt_template, arguments=arguments)
    
    # 6. 输出结果
    print("生成的文档内容：")
    print(result)
    print("\n" + "="*50)
    print(f"元数据：Tokens使用量 - {result.metadata.get('usage', {})}")

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

3.3 直接使用AI服务

如果不需要完整的Kernel功能，可以直接使用AI服务：

# direct_ai_service.py
import asyncio
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion, OpenAIChatPromptExecutionSettings
from semantic_kernel.contents import ChatHistory

async def direct_service_demo():
    """直接使用AI服务演示"""
    
    # 1. 创建服务实例
    service = OpenAIChatCompletion()
    
    # 2. 配置执行设置
    settings = OpenAIChatPromptExecutionSettings(
        temperature=0.7,
        max_tokens=1000
    )
    
    # 3. 创建聊天历史
    chat_history = ChatHistory()
    chat_history.add_system_message("你是一个有帮助的AI助手，擅长解释技术概念。")
    chat_history.add_user_message("请用简单的语言解释什么是机器学习？")
    
    # 4. 获取响应
    response = await service.get_chat_message_content(
        chat_history=chat_history, 
        settings=settings
    )
    
    print("AI响应：")
    print(response.content)
    print(f"\nTokens使用情况：{response.metadata}")

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

4. 智能体开发：构建AI助手

4.1 基础智能体创建

# basic_agent.py
import asyncio
from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion

async def create_basic_agent():
    """创建基础聊天智能体"""
    
    # 创建AI服务
    chat_service = OpenAIChatCompletion()
    
    # 创建智能体
    agent = ChatCompletionAgent(
        service=chat_service,
        name="TechAssistant",
        instructions="""
你是一个专业的技术支持助手，擅长：
1. 解释复杂的技术概念
2. 提供编程建议和最佳实践
3. 调试代码问题
4. 推荐学习资源

请保持回答专业、准确且易于理解。
"""
    )
    
    # 测试智能体
    test_messages = [
        "解释一下Python中的装饰器是什么？",
        "如何优化数据库查询性能？",
        "推荐学习机器学习的资源"
    ]
    
    for message in test_messages:
        print(f"用户: {message}")
        response = await agent.get_response(messages=message)
        print(f"助手: {response.content}")
        print("-" * 50)

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

4.2 带插件的智能体

创建具有自定义功能的智能体：

# agent_with_plugins.py
import asyncio
from typing import Annotated
from datetime import datetime
from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.functions import kernel_function

class UtilityPlugin:
    """工具插件，提供实用功能"""
    
    @kernel_function(description="获取当前时间和日期")
    def get_current_time(self) -> Annotated[str, "返回当前时间和日期"]:
        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    
    @kernel_function(description="计算两个数字的和")
    def add_numbers(
        self, 
        a: Annotated[float, "第一个数字"],
        b: Annotated[float, "第二个数字"]
    ) -> Annotated[float, "两个数字的和"]:
        return a + b
    
    @kernel_function(description="将温度从摄氏度转换为华氏度")
    def celsius_to_fahrenheit(
        self, 
        celsius: Annotated[float, "摄氏度温度"]
    ) -> Annotated[float, "华氏度温度"]:
        return (celsius * 9/5) + 32

async def agent_with_tools():
    """创建带工具插件的智能体"""
    
    # 创建插件实例
    utility_plugin = UtilityPlugin()
    
    # 创建智能体
    agent = ChatCompletionAgent(
        service=OpenAIChatCompletion(),
        name="SmartAssistant",
        instructions="你是一个多功能助手，可以使用各种工具来帮助用户。",
        plugins=[utility_plugin]
    )
    
    # 测试用例
    test_cases = [
        "现在几点了？",
        "计算一下25加38等于多少？",
        "20摄氏度是多少华氏度？",
        "请告诉我当前时间，然后计算30+45的值"
    ]
    
    for case in test_cases:
        print(f"用户: {case}")
        response = await agent.get_response(messages=case)
        print(f"助手: {response.content}")
        print("=" * 60)

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

5. 多模型集成实战

5.1 配置多AI服务提供商

# multi_provider_setup.py
import os
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion, AzureChatCompletion
from semantic_kernel.connectors.ai.hugging_face import HuggingFaceTextCompletion

class MultiProviderKernel:
    """多AI服务提供商配置"""
    
    def __init__(self):
        self.kernel = Kernel()
        self.setup_services()
    
    def setup_services(self):
        """配置多个AI服务"""
        
        # OpenAI服务
        if os.getenv('OPENAI_API_KEY'):
            openai_service = OpenAIChatCompletion(
                ai_model_id=os.getenv('OPENAI_MODEL_ID', 'gpt-4o')
            )
            self.kernel.add_service(openai_service, service_id="openai")
            print("✅ OpenAI服务配置成功")
        
        # Azure OpenAI服务
        if all([
            os.getenv('AZURE_OPENAI_API_KEY'),
            os.getenv('AZURE_OPENAI_ENDPOINT'),
            os.getenv('AZURE_OPENAI_CHAT_DEPLOYMENT_NAME')
        ]):
            azure_service = AzureChatCompletion(
                deployment_name=os.getenv('AZURE_OPENAI_CHAT_DEPLOYMENT_NAME'),
                endpoint=os.getenv('AZURE_OPENAI_ENDPOINT'),
                api_key=os.getenv('AZURE_OPENAI_API_KEY')
            )
            self.kernel.add_service(azure_service, service_id="azure")
            print("✅ Azure OpenAI服务配置成功")
        
        # Hugging Face服务（可选）
        if os.getenv('HUGGINGFACE_API_KEY'):
            try:
                hf_service = HuggingFaceTextCompletion(
                    ai_model_id=os.getenv('HUGGINGFACE_MODEL', 'gpt2')
                )
                self.kernel.add_service(hf_service, service_id="huggingface")
                print("✅ Hugging Face服务配置成功")
            except ImportError:
                print("⚠️  Hugging Face支持需要安装: pip install semantic-kernel[hugging_face]")
    
    async def run_with_provider(self, prompt: str, provider: str = "openai"):
        """使用指定提供商运行提示"""
        arguments = {"input": prompt}
        
        try:
            result = await self.kernel.invoke_prompt(
                "{{$input}}",
                arguments=arguments,
                service_id=provider
            )
            return result
        except Exception as e:
            return f"错误: {str(e)}"

# 使用示例
async def demo_multi_provider():
    kernel_manager = MultiProviderKernel()
    
    test_prompt = "解释一下云计算的基本概念"
    
    # 尝试不同的提供商
    providers = ["openai", "azure", "huggingface"]
    
    for provider in providers:
        print(f"\n使用 {provider} 提供商:")
        result = await kernel_manager.run_with_provider(test_prompt, provider)
        print(f"结果: {result}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(demo_multi_provider())

5.2 智能路由和故障转移

# smart_routing.py
import asyncio
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion

class SmartRouter:
    """智能路由和故障转移机制"""
    
    def __init__(self):
        self.kernel = Kernel()
        self.setup_services()
        self.priority_order = ["openai_primary", "openai_backup", "azure"]
    
    def setup_services(self):
        """设置多服务实例"""
        # 主OpenAI服务
        self.kernel.add_service(
            OpenAIChatCompletion(ai_model_id="gpt-4o"),
            service_id="openai_primary"
        )
        
        # 备份OpenAI服务（不同模型）
        self.kernel.add_service(
            OpenAIChatCompletion(ai_model_id="gpt-3.5-turbo"),
            service_id="openai_backup"
        )
    
    async def invoke_with_fallback(self, prompt: str, max_retries: int = 3):
        """带故障转移的调用"""
        last_error = None
        
        for attempt, service_id in enumerate(self.priority_order[:max_retries]):
            try:
                print(f"尝试使用 {service_id} (尝试 {attempt + 1}/{max_retries})")
                
                result = await self.kernel.invoke_prompt(
                    "{{$input}}",
                    arguments={"input": prompt},
                    service_id=service_id
                )
                
                print(f"✅ 成功使用 {service_id}")
                return result, service_id
                
            except Exception as e:
                last_error = e
                print(f"❌ {service_id} 失败: {str(e)}")
                continue
        
        raise Exception(f"所有服务都失败: {last_error}")

async def demo_smart_routing():
    router = SmartRouter()
    
    test_prompts = [
        "写一个Python函数来计算斐波那契数列",
        "解释机器学习中的过拟合现象",
        "如何设计一个可扩展的微服务架构？"
    ]
    
    for i, prompt in enumerate(test_prompts):
        print(f"\n{'='*60}")
        print(f"处理提示 {i+1}: {prompt}")
        
        try:
            result, used_service = await router.invoke_with_fallback(prompt)
            print(f"使用的服务: {used_service}")
            print(f"结果: {result}")
        except Exception as e:
            print(f"全部失败: {e}")

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

6. 高级特性：流程和编排

6.1 多智能体协作系统

# multi_agent_system.py
import asyncio
from semantic_kernel.agents import ChatCompletionAgent, GroupChatOrchestration, RoundRobinGroupChatManager
from semantic_kernel.agents.runtime import InProcessRuntime
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion

def create_specialized_agents():
    """创建专业化的智能体团队"""
    
    # 技术写作智能体
    writer_agent = ChatCompletionAgent(
        name="技术作家",
        service=OpenAIChatCompletion(),
        instructions="""
你是专业的技术文档作家，擅长：
- 将复杂技术概念转化为易懂的文字
- 编写结构清晰的文档和教程
- 保持技术准确性和可读性的平衡
- 使用恰当的术语和示例
"""
    )
    
    # 代码审查智能体
    reviewer_agent = ChatCompletionAgent(
        name="代码审查员",
        service=OpenAIChatCompletion(),
        instructions="""
你是资深的代码审查专家，擅长：
- 发现代码中的潜在问题和优化点
- 提出改进建议和最佳实践
- 检查代码风格和一致性
- 确保代码质量和可维护性
"""
    )
    
    # 架构师智能体
    architect_agent = ChatCompletionAgent(
        name="系统架构师",
        service=OpenAIChatCompletion(),
        instructions="""
你是经验丰富的系统架构师，擅长：
- 设计可扩展的系统架构
- 评估技术选型和方案
- 规划系统演进路线
- 考虑性能、安全和成本因素
"""
    )
    
    return [writer_agent, reviewer_agent, architect_agent]

async def collaborative_design():
    """多智能体协作设计演示"""
    
    agents = create_specialized_agents()
    
    # 创建群聊编排
    group_chat = GroupChatOrchestration(
        members=agents,
        manager=RoundRobinGroupChatManager(max_rounds=5),
        instructions="协作完成一个技术方案设计"
    )
    
    # 创建运行时环境
    runtime = InProcessRuntime()
    runtime.start()
    
    try:
        # 启动协作任务
        task_description = """
设计一个基于Python的微服务电商系统，要求：
1. 支持用户管理、商品管理、订单处理
2. 使用Redis缓存和PostgreSQL数据库
3. 实现API网关和服务发现
4. 考虑高可用和扩展性

请给出系统架构设计、技术选型建议和实现路线图。
"""
        
        print("开始多智能体协作...")
        result = await group_chat.invoke(
            task=task_description,
            runtime=runtime
        )
        
        final_result = await result.get()
        print("\n最终设计方案：")
        print(final_result)
        
    finally:
        await runtime.stop_when_idle()

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

6.2 结构化流程引擎

# structured_process.py
import asyncio
from typing import List, Dict, Any
from pydantic import BaseModel
from semantic_kernel.processes import Process, Step, ProcessContext
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion

class TechnicalPlan(BaseModel):
    """技术方案数据结构"""
    architecture: str
    technologies: List[str]
    timeline: Dict[str, str]
    risks: List[str]

class TechnicalPlanningProcess(Process):
    """技术方案规划流程"""
    
    def __init__(self):
        super().__init__(
            name="技术方案规划流程",
            description="从需求分析到技术方案制定的完整流程"
        )
        
        # 定义流程步骤
        self.steps = [
            Step(
                name="需求分析",
                description="分析业务需求和技术要求",
                handler=self.analyze_requirements
            ),
            Step(
                name="技术选型",
                description="选择合适的技术栈和工具",
                handler=self.select_technologies
            ),
            Step(
                name="架构设计",
                description="设计系统架构和组件",
                handler=self.design_architecture
            ),
            Step(
                name="风险评估",
                description="识别和评估技术风险",
                handler=self.assess_risks
            ),
            Step(
                name="方案整合",
                description="整合所有分析结果形成最终方案",
                handler=self.integrate_solution
            )
        ]
    
    async def analyze_requirements(self, context: ProcessContext) -> None:
        """需求分析步骤"""
        ai_service = OpenAIChatCompletion()
        
        requirement_prompt = f"""
分析以下技术需求并提取关键信息：

需求：{context.input}

请提取：
1. 核心业务需求
2. 技术要求和非功能性需求
3. 预期的系统规模和使用场景
"""
        
        analysis = await ai_service.get_chat_message_content(requirement_prompt)
        context.state["requirement_analysis"] = analysis.content
    
    async def select_technologies(self, context: ProcessContext) -> None:
        """技术选型步骤"""
        ai_service = OpenAIChatCompletion()
        
        selection_prompt = f"""
基于以下需求分析，推荐合适的技术栈：

{context.state['requirement_analysis']}

考虑因素：
- 项目规模和技术复杂度
- 团队技术背景
- 社区支持和生态系统
- 长期维护成本
"""
        
        selection = await ai_service.get_chat_message_content(selection_prompt)
        context.state["technology_selection"] = selection.content
    
    async def design_architecture(self, context: ProcessContext) -> None:
        """架构设计步骤"""
        ai_service = OpenAIChatCompletion()
        
        architecture_prompt = f"""
基于需求分析和技术选型，设计系统架构：

需求分析：{context.state['requirement_analysis']}
技术选型：{context.state['technology_selection']}

请设计：
1. 系统组件和模块划分
2. 数据流和通信机制
3. 部署架构
4. 扩展性考虑
"""
        
        architecture = await ai_service.get_chat_message_content(architecture_prompt)
        context.state["architecture_design"] = architecture.content
    
    async def assess_risks(self, context: ProcessContext) -> None:
        """风险评估步骤"""
        ai_service = OpenAIChatCompletion()
        
        risk_prompt = f"""
识别以下技术方案中的潜在风险：

架构设计：{context.state['architecture_design']}
技术选型：{context.state['technology_selection']}

请评估：
1. 技术风险
2. 实施风险
3. 运维风险
4. 应对策略
"""
        
        risk_assessment = await ai_service.get_chat_message_content(risk_prompt)
        context.state["risk_assessment"] = risk_assessment.content
    
    async def integrate_solution(self, context: ProcessContext) -> TechnicalPlan:
        """方案整合步骤"""
        ai_service = OpenAIChatCompletion()
        
        integration_prompt = f"""
整合以下分析结果形成完整的技术方案：

需求分析：{context.state['requirement_analysis']}
技术选型：{context.state['technology_selection']}
架构设计：{context.state['architecture_design']}
风险评估：{context.state['risk_assessment']}

请生成结构化的技术方案，包括架构、技术栈、时间规划和风险应对。
"""
        
        final_solution = await ai_service.get_chat_message_content(integration_prompt)
        
        # 返回结构化的方案
        return TechnicalPlan(
            architecture=context.state["architecture_design"],
            technologies=context.state["technology_selection"].split("\n"),
            timeline={"阶段1": "需求分析和设计", "阶段2": "开发和测试"},
            risks=context.state["risk_assessment"].split("\n")
        )

async def run_technical_planning():
    """运行技术规划流程"""
    process = TechnicalPlanningProcess()
    
    # 定义技术需求
    tech_requirement = """
我们需要开发一个在线教育平台，支持：
- 视频课程上传和播放
- 实时在线课堂
- 学生进度跟踪
- 教师管理功能
- 移动端支持

预期用户量：初期1万，一年内扩展到10万
技术团队：15人，主要技术栈是Python和JavaScript
"""
    
    print("启动技术规划流程...")
    result = await process.run(tech_requirement)
    
    print("\n最终技术方案：")
    print(f"架构设计: {result.architecture}")
    print(f"技术选型: {result.technologies}")
    print(f"时间规划: {result.timeline}")
    print(f"风险评估: {result.risks}")

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

7. 生产环境部署

7.1 Docker容器化部署

创建Dockerfile用于生产环境部署：

# Dockerfile
FROM python:3.11-slim

# 设置工作目录
WORKDIR /app

# 设置环境变量
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1
ENV PIP_NO_CACHE_DIR=1

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    gcc \
    && rm -rf /var/lib/apt/lists/*

# 复制依赖文件
COPY requirements.txt .

# 安装Python依赖
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 创建非root用户
RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
USER appuser

# 暴露端口
EXPOSE 8000

# 启动命令
CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

创建对应的requirements.txt：

semantic-kernel==1.0.0
fastapi==0.104.1
uvicorn[standard]==0.24.0
python-dotenv==1.0.0
aiohttp==3.9.1
pydantic==2.5.0

7.2 FastAPI Web服务集成

创建生产级的Web服务：

# main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional
import asyncio
import logging
from contextlib import asynccontextmanager

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.agents import ChatCompletionAgent

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# 定义数据模型
class ChatRequest(BaseModel):
    message: str
    session_id: Optional[str] = None
    temperature: float = 0.7

class ChatResponse(BaseModel):
    response: str
    session_id: str
    tokens_used: int

class HealthResponse(BaseModel):
    status: str
    version: str
    services: List[str]

# 全局应用状态
class AppState:
    def __init__(self):
        self.kernel: Optional[Kernel] = None
        self.agent: Optional[ChatCompletionAgent] = None

app_state = AppState()

@asynccontextmanager
async def lifespan(app: FastAPI):
    """应用生命周期管理"""
    # 启动时初始化
    logger.info("初始化Semantic Kernel服务...")
    
    try:
        # 创建Kernel实例
        app_state.kernel = Kernel()
        app_state.kernel.add_service(OpenAIChatCompletion())
        
        # 创建智能体
        app_state.agent = ChatCompletionAgent(
            service=OpenAIChatCompletion(),
            name="API-Assistant",
            instructions="你是一个专业的API助手，帮助用户解决技术问题。"
        )
        
        logger.info("Semantic Kernel服务初始化完成")
        yield
        
    except Exception as e:
        logger.error(f"初始化失败: {e}")
        raise
    
    finally:
        # 清理资源
        logger.info("关闭Semantic Kernel服务...")

# 创建FastAPI应用
app = FastAPI(
    title="Semantic Kernel API服务",
    description="基于FastAPI和Semantic Kernel的AI服务API",
    version="1.0.0",
    lifespan=lifespan
)

@app.get("/health")
async def health_check() -> HealthResponse:
    """健康检查端点"""
    services = []
    if app_state.kernel:
        services = list(app_state.kernel.services.keys())
    
    return HealthResponse(
        status="healthy",
        version="1.0.0",
        services=services
    )

@app.post("/chat", response_model=ChatResponse)
async def chat_endpoint(request: ChatRequest):
    """聊天对话端点"""
    try:
        if not app_state.agent:
            raise HTTPException(status_code=503, detail="服务未就绪")
        
        # 调用智能体
        response = await app_state.agent.get_response(
            messages=request.message
        )
        
        return ChatResponse(
            response=response.content,
            session_id=request.session_id or "default-session",
            tokens_used=response.metadata.get("usage", {}).get("total_tokens", 0)
        )
        
    except Exception as e:
        logger.error(f"聊天处理错误: {e}")
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/models")
async def list_models():
    """获取可用模型列表"""
    return {
        "models": ["gpt-4o", "gpt-3.5-turbo"],
        "current_model": "gpt-4o"
    }

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

7.3 性能优化配置

创建性能优化配置文件：

# performance_config.py
import os
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion, OpenAIChatPromptExecutionSettings

class OptimizedKernelConfig:

【免费下载链接】semantic-kernel Integrate cutting-edge LLM technology quickly and easily into your apps 项目地址: https://gitcode.com/GitHub_Trending/se/semantic-kernel

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考