AI Agent在礼品包装与定制服务中的应用：个性化设计与自动化生产

---

1. 标题 (Title)

• AI Agent赋能礼品行业：打造个性化设计与自动化生产的未来体验
• 从零到一：构建AI驱动的智能礼品包装与定制服务系统
• 礼品行业革命：AI Agent如何实现个性化设计与自动化生产的完美融合
• 智能定制时代：用AI Agent重构礼品包装设计与生产流程

---

2. 引言 (Introduction)

痛点引入 (Hook)

你是否有过这样的经历：为了给亲朋好友挑选一份独特的礼物，在商场或网上浏览数小时，却始终找不到完全符合心意的礼品包装？或者作为礼品店老板，面对客户千奇百怪的个性化需求，既无法快速提供专业的设计方案，又难以控制定制生产的成本和周期？在这个追求个性化体验的时代，传统的礼品包装与定制服务模式正面临着前所未有的挑战。

文章内容概述 (What)

本文将带你深入探索如何利用AI Agent技术重构礼品包装与定制服务。我们将从概念解析开始，逐步构建一个完整的智能系统，包括个性化设计生成、客户需求理解、自动化生产调度等核心功能。通过实际的代码示例和系统设计，你将看到AI Agent如何在这一传统行业中发挥革命性作用。

读者收益 (Why)

读完本文，你将理解AI Agent在礼品行业的应用价值，掌握构建智能定制系统的核心技术，学会如何将AI技术与传统业务流程有机结合。无论你是想创业的开发者，还是寻求技术升级的礼品行业从业者，这篇文章都将为你提供宝贵的思路和实践指南。

---

3. 准备工作 (Prerequisites)

技术栈/知识

• 熟悉Python编程基础
• 了解基本的机器学习概念
• 对Web开发有基本认识（前端/后端）
• 了解AI Agent的基本概念和工作原理

环境/工具

• 已安装Python 3.8+环境
• 熟悉使用pip或conda管理依赖包
• 可选：拥有OpenAI API密钥或其他大语言模型访问权限
• 可选：基础的Docker知识（用于环境隔离和部署）

---

4. 核心内容：手把手实战 (Step-by-Step Tutorial)

步骤一：AI Agent基础与系统架构设计

什么是AI Agent？

AI Agent是一种能够感知环境、做出决策并执行行动的智能系统。它通常具备以下核心能力：感知能力、推理能力、规划能力、执行能力和学习能力。在礼品包装与定制服务场景中，AI Agent将扮演设计师、顾问和生产调度员等多重角色。

系统整体架构

我们的智能礼品包装定制系统将包含以下核心模块：

1. 用户交互界面：收集客户需求，展示设计方案
2. 需求理解Agent：解析客户需求，提取关键参数
3. 设计生成Agent：基于需求生成个性化包装设计
4. 设计评估Agent：评估设计方案的可行性和吸引力
5. 生产调度Agent：将设计转化为生产指令，优化生产流程
6. 数据存储与知识库：存储设计模板、材质库、生产参数等

让我们用Mermaid来可视化这个系统架构：

步骤二：构建需求理解Agent

在礼品包装定制服务中，准确理解客户需求是第一步也是最关键的一步。客户可能会用自然语言描述他们想要的礼品包装，例如：“我想要一个浪漫风格的情人节礼物包装，用红色和粉色为主色调，加上一些心形元素，包装的是一条项链。”

我们的需求理解Agent需要将这样的自然语言描述转化为结构化的设计参数。

环境设置

首先，让我们设置基本的Python环境：

# requirements.txt
openai==1.3.0
pydantic==2.5.0
python-dotenv==1.0.0

需求理解Agent实现

下面是一个简化版的需求理解Agent实现：

import os
from typing import List, Optional
from pydantic import BaseModel, Field
from dotenv import load_dotenv
import openai

# 加载环境变量
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

# 定义结构化需求的数据模型
class GiftPackageRequirements(BaseModel):
    occasion: str = Field(description="礼品的场合，如生日、情人节、婚礼等")
    style: str = Field(description="包装风格，如简约、浪漫、复古、现代等")
    primary_colors: List[str] = Field(description="主要颜色列表")
    secondary_colors: Optional[List[str]] = Field(description="次要颜色列表，可选")
    elements: List[str] = Field(description="设计元素，如心形、星星、花朵等")
    gift_type: str = Field(description="礼品类型，如首饰、服装、书籍等")
    size: Optional[str] = Field(description="包装尺寸，如果未指定则需要后续询问")
    special_requirements: Optional[str] = Field(description="其他特殊要求")

class RequirementsUnderstandingAgent:
    def __init__(self):
        self.client = openai.OpenAI()
    
    def parse_requirements(self, user_description: str) -> GiftPackageRequirements:
        """
        使用LLM解析用户的自然语言需求，转化为结构化参数
        """
        system_prompt = """
        你是一个专业的礼品包装需求分析师。你的任务是将用户的自然语言描述转化为结构化的礼品包装需求参数。
        
        请根据用户描述，提取以下信息：
        - occasion: 礼品的场合
        - style: 包装风格
        - primary_colors: 主要颜色列表
        - secondary_colors: 次要颜色列表（可选）
        - elements: 设计元素
        - gift_type: 礼品类型
        - size: 包装尺寸（如果用户未明确提及，保持为null）
        - special_requirements: 其他特殊要求（如果有）
        
        请以JSON格式输出结果。
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_description}
            ],
            response_format={"type": "json_object"}
        )
        
        # 解析LLM返回的JSON
        import json
        requirements_json = json.loads(response.choices[0].message.content)
        
        # 验证并创建结构化需求对象
        return GiftPackageRequirements(**requirements_json)
    
    def check_missing_info(self, requirements: GiftPackageRequirements) -> List[str]:
        """
        检查是否有缺失的关键信息，返回需要询问用户的问题列表
        """
        missing = []
        if not requirements.size:
            missing.append("请问礼品的大致尺寸是多少？这样我们可以为您推荐合适的包装规格。")
        return missing

# 使用示例
if __name__ == "__main__":
    agent = RequirementsUnderstandingAgent()
    user_input = "我想要一个浪漫风格的情人节礼物包装，用红色和粉色为主色调，加上一些心形元素，包装的是一条项链。"
    
    requirements = agent.parse_requirements(user_input)
    print("解析到的需求：")
    print(requirements.model_dump_json(indent=2))
    
    missing_questions = agent.check_missing_info(requirements)
    if missing_questions:
        print("\n需要补充的信息：")
        for question in missing_questions:
            print(f"- {question}")

这个需求理解Agent使用OpenAI的GPT模型将用户的自然语言描述转化为结构化数据，并检查是否有遗漏的关键信息。

步骤三：构建设计生成Agent

设计生成Agent是整个系统的核心，它需要根据理解到的需求参数，生成具体的礼品包装设计方案。这里我们将结合文本生成和图像生成技术。

设计模板库

首先，我们需要建立一个基础的设计模板库：

from typing import Dict, List, Optional
from dataclasses import dataclass
from enum import Enum

class MaterialType(Enum):
    PAPER = "paper"
    FABRIC = "fabric"
    RIBBON = "ribbon"
    ACCESSORY = "accessory"

@dataclass
class Material:
    id: str
    name: str
    type: MaterialType
    color: str
    texture: Optional[str] = None
    image_url: Optional[str] = None
    cost: float = 0.0

@dataclass
class DesignTemplate:
    id: str
    name: str
    style: str
    occasion: str
    materials: List[Material]
    layout_description: str
    difficulty_level: int  # 1-5, 1最简单
    estimated_time: int  # 分钟
    popularity_score: float = 0.0

class DesignLibrary:
    def __init__(self):
        self.templates: Dict[str, DesignTemplate] = {}
        self.materials: Dict[str, Material] = {}
        
    def add_template(self, template: DesignTemplate):
        self.templates[template.id] = template
        
    def add_material(self, material: Material):
        self.materials[material.id] = material
        
    def find_templates(self, style: Optional[str] = None, 
                       occasion: Optional[str] = None) -> List[DesignTemplate]:
        """根据风格和场合查找合适的模板"""
        results = list(self.templates.values())
        if style:
            results = [t for t in results if t.style == style]
        if occasion:
            results = [t for t in results if t.occasion == occasion]
        return sorted(results, key=lambda t: t.popularity_score, reverse=True)

设计生成Agent实现

现在让我们实现设计生成Agent，它将结合模板库和AI能力生成设计方案：

import random
from typing import List, Tuple
import openai

class DesignGenerationAgent:
    def __init__(self, design_library: DesignLibrary, openai_api_key: str):
        self.library = design_library
        self.client = openai.OpenAI(api_key=openai_api_key)
    
    def generate_design_concepts(self, requirements: GiftPackageRequirements, 
                                  num_concepts: int = 3) -> List[Dict]:
        """
        生成多个设计概念方案
        """
        # 查找基础模板
        base_templates = self.library.find_templates(
            style=requirements.style, 
            occasion=requirements.occasion
        )
        
        # 如果没有找到完全匹配的，放宽条件
        if not base_templates:
            base_templates = self.library.find_templates(style=requirements.style)
        if not base_templates:
            base_templates = self.library.find_templates(occasion=requirements.occasion)
        if not base_templates:
            base_templates = list(self.library.templates.values())[:5]
        
        # 生成设计概念
        concepts = []
        for i in range(min(num_concepts, len(base_templates))):
            concept = self._adapt_template_to_requirements(
                base_templates[i], requirements, i
            )
            concepts.append(concept)
        
        return concepts
    
    def _adapt_template_to_requirements(self, template: DesignTemplate, 
                                        requirements: GiftPackageRequirements,
                                        concept_id: int) -> Dict:
        """
        将基础模板调整为符合用户需求的设计概念
        """
        # 调整颜色方案
        adapted_materials = self._adjust_colors(template.materials, requirements)
        
        # 生成设计描述
        design_description = self._generate_design_description(template, requirements)
        
        # 生成图像提示词
        image_prompt = self._generate_image_prompt(requirements, design_description)
        
        return {
            "concept_id": concept_id,
            "name": f"{requirements.style.capitalize()} {requirements.occasion} Concept {concept_id + 1}",
            "base_template": template.id,
            "materials": adapted_materials,
            "description": design_description,
            "image_prompt": image_prompt,
            "estimated_cost": sum(m.cost for m in adapted_materials),
            "estimated_time": template.estimated_time,
            "difficulty_level": template.difficulty_level
        }
    
    def _adjust_colors(self, materials: List[Material], 
                      requirements: GiftPackageRequirements) -> List[Material]:
        """
        调整材料颜色以符合用户需求
        """
        adapted = []
        primary_color = random.choice(requirements.primary_colors)
        
        for material in materials:
            # 为每种材料寻找颜色匹配的替代选项或调整颜色
            new_material = Material(
                id=material.id,
                name=material.name,
                type=material.type,
                color=primary_color if material.type != MaterialType.ACCESSORY else material.color,
                texture=material.texture,
                image_url=material.image_url,
                cost=material.cost
            )
            adapted.append(new_material)
        
        return adapted
    
    def _generate_design_description(self, template: DesignTemplate, 
                                     requirements: GiftPackageRequirements) -> str:
        """
        使用LLM生成详细的设计描述
        """
        prompt = f"""
        请为一个{requirements.occasion}礼品包装设计生成一段吸引人的描述。
        
        设计风格：{requirements.style}
        主要颜色：{', '.join(requirements.primary_colors)}
        设计元素：{', '.join(requirements.elements)}
        礼品类型：{requirements.gift_type}
        基础布局：{template.layout_description}
        
        请生成一段200字左右的设计描述，突出设计的特点和适用场景。
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}]
        )
        
        return response.choices[0].message.content
    
    def _generate_image_prompt(self, requirements: GiftPackageRequirements, 
                               description: str) -> str:
        """
        生成用于图像生成模型的提示词
        """
        prompt = f"""
        专业礼品包装设计，{requirements.occasion}场合，{requirements.style}风格。
        主色调：{', '.join(requirements.primary_colors)}。
        设计元素：{', '.join(requirements.elements)}。
        包装的礼品：{requirements.gift_type}。
        设计描述：{description}。
        
        高质量，产品摄影风格，明亮的照明，细节丰富。
        """
        return prompt

步骤四：设计评估与优化Agent

生成多个设计概念后，我们需要一个评估Agent来分析这些设计的优缺点，并根据用户反馈进行优化。

from typing import Dict, List, Tuple
import openai

class DesignEvaluationAgent:
    def __init__(self, openai_api_key: str):
        self.client = openai.OpenAI(api_key=openai_api_key)
    
    def evaluate_designs(self, concepts: List[Dict], 
                        requirements: GiftPackageRequirements) -> List[Dict]:
        """
        评估多个设计概念，添加评分和改进建议
        """
        evaluated_concepts = []
        
        for concept in concepts:
            evaluation = self._evaluate_single_design(concept, requirements)
            concept_with_eval = {**concept, **evaluation}
            evaluated_concepts.append(concept_with_eval)
        
        # 按综合评分排序
        return sorted(evaluated_concepts, key=lambda x: x["overall_score"], reverse=True)
    
    def _evaluate_single_design(self, concept: Dict, 
                                requirements: GiftPackageRequirements) -> Dict:
        """
        评估单个设计概念
        """
        prompt = f"""
        请评估以下礼品包装设计概念，从以下几个维度进行评分（1-10分）：
        1. 美学吸引力：设计是否美观
        2. 需求匹配度：是否符合客户需求
        3. 生产可行性：是否容易生产
        4. 成本效益：成本是否合理
        
        设计概念：
        - 名称：{concept['name']}
        - 描述：{concept['description']}
        - 估计成本：{concept['estimated_cost']}
        - 难度级别：{concept['difficulty_level']}
        
        客户需求：
        - 场合：{requirements.occasion}
        - 风格：{requirements.style}
        - 主色调：{', '.join(requirements.primary_colors)}
        - 设计元素：{', '.join(requirements.elements)}
        - 礼品类型：{requirements.gift_type}
        
        请以JSON格式返回评分结果和简短的改进建议。
        JSON格式示例：
        {{
            "aesthetics_score": 8,
            "requirements_match_score": 9,
            "feasibility_score": 7,
            "cost_effectiveness_score": 6,
            "overall_score": 7.5,
            "suggestions": ["建议增加一些丝带元素", "可以考虑调整配色比例"]
        }}
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}],
            response_format={"type": "json_object"}
        )
        
        import json
        return json.loads(response.choices[0].message.content)
    
    def optimize_design(self, concept: Dict, feedback: str, 
                       requirements: GiftPackageRequirements) -> Dict:
        """
        根据用户反馈优化设计
        """
        prompt = f"""
        根据以下用户反馈，优化礼品包装设计：
        
        原始设计：
        - 名称：{concept['name']}
        - 描述：{concept['description']}
        
        用户反馈：{feedback}
        
        客户基本需求：
        - 场合：{requirements.occasion}
        - 风格：{requirements.style}
        - 主色调：{', '.join(requirements.primary_colors)}
        
        请提供优化后的设计描述和具体的修改建议。
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}]
        )
        
        optimized_description = response.choices[0].message.content
        
        # 更新设计概念
        optimized_concept = concept.copy()
        optimized_concept["description"] = optimized_description
        optimized_concept["optimized_from"] = concept["concept_id"]
        
        return optimized_concept

步骤五：生产调度与自动化

一旦用户确认了最终设计，我们需要将设计转化为生产指令，并优化整个生产流程。这就是生产调度Agent的任务。

from typing import Dict, List, Optional
from dataclasses import dataclass
from enum import Enum
import datetime
import heapq

class ProductionStatus(Enum):
    PENDING = "pending"
    IN_PROGRESS = "in_progress"
    COMPLETED = "completed"
    DELAYED = "delayed"

@dataclass
class ProductionStep:
    id: str
    name: str
    description: str
    estimated_duration: int  # 分钟
    required_tools: List[str]
    dependencies: List[str]  # 依赖的步骤ID
    status: ProductionStatus = ProductionStatus.PENDING
    start_time: Optional[datetime.datetime] = None
    end_time: Optional[datetime.datetime] = None

@dataclass
class ProductionOrder:
    id: str
    design_concept: Dict
    priority: int  # 1-5, 5最高优先级
    deadline: datetime.datetime
    steps: List[ProductionStep]
    status: ProductionStatus = ProductionStatus.PENDING
    assigned_machine: Optional[str] = None

class Machine:
    def __init__(self, id: str, name: str, capabilities: List[str]):
        self.id = id
        self.name = name
        self.capabilities = capabilities
        self.current_order: Optional[ProductionOrder] = None
        self.schedule: List[Tuple[datetime.datetime, datetime.datetime, str]] = []  # (开始时间, 结束时间, 订单ID)
    
    def is_available(self, start_time: datetime.datetime, duration: int) -> bool:
        """检查机器在指定时间段是否可用"""
        end_time = start_time + datetime.timedelta(minutes=duration)
        
        for scheduled_start, scheduled_end, _ in self.schedule:
            if not (end_time <= scheduled_start or start_time >= scheduled_end):
                return False
        return True
    
    def assign_time_slot(self, order_id: str, start_time: datetime.datetime, duration: int) -> bool:
        """分配时间槽给订单"""
        if not self.is_available(start_time, duration):
            return False
        
        end_time = start_time + datetime.timedelta(minutes=duration)
        heapq.heappush(self.schedule, (start_time, end_time, order_id))
        return True

class ProductionSchedulingAgent:
    def __init__(self):
        self.machines: Dict[str, Machine] = {}
        self.orders: Dict[str, ProductionOrder] = {}
        self.production_steps_templates = self._init_step_templates()
    
    def _init_step_templates(self) -> Dict[str, List[ProductionStep]]:
        """初始化生产步骤模板"""
        return {
            "simple_package": [
                ProductionStep(
                    id="material_prep",
                    name="材料准备",
                    description="准备包装纸、丝带和装饰元素",
                    estimated_duration=10,
                    required_tools=["剪刀", "测量工具"],
                    dependencies=[]
                ),
                ProductionStep(
                    id="wrapping",
                    name="包装",
                    description="按照设计要求包装礼品",
                    estimated_duration=15,
                    required_tools=["胶带", "包装纸"],
                    dependencies=["material_prep"]
                ),
                ProductionStep(
                    id="decorating",
                    name="装饰",
                    description="添加丝带、卡片和其他装饰元素",
                    estimated_duration=10,
                    required_tools=["胶水", "丝带"],
                    dependencies=["wrapping"]
                ),
                ProductionStep(
                    id="quality_check",
                    name="质量检查",
                    description="检查最终产品是否符合设计要求",
                    estimated_duration=5,
                    required_tools=["检查清单"],
                    dependencies=["decorating"]
                )
            ],
            # 可以添加更多模板
        }
    
    def add_machine(self, machine: Machine):
        """添加生产设备"""
        self.machines[machine.id] = machine
    
    def create_production_order(self, design_concept: Dict, 
                                priority: int = 3,
                                deadline_days: int = 3) -> ProductionOrder:
        """创建生产订单"""
        order_id = f"ORDER_{datetime.datetime.now().strftime('%Y%m%d%H%M%S')}"
        deadline = datetime.datetime.now() + datetime.timedelta(days=deadline_days)
        
        # 根据设计复杂度选择生产步骤模板
        if design_concept["difficulty_level"] <= 2:
            steps_template = self.production_steps_templates["simple_package"]
        else:
            # 对于更复杂的设计，可以使用更详细的模板
            steps_template = self.production_steps_templates["simple_package"]  # 简化处理
        
        # 复制步骤模板
        steps = []
        for step_template in steps_template:
            step = ProductionStep(
                id=step_template.id,
                name=step_template.name,
                description=step_template.description,
                estimated_duration=step_template.estimated_duration,
                required_tools=step_template.required_tools.copy(),
                dependencies=step_template.dependencies.copy()
            )
            steps.append(step)
        
        order = ProductionOrder(
            id=order_id,
            design_concept=design_concept,
            priority=priority,
            deadline=deadline,
            steps=steps
        )
        
        self.orders[order_id] = order
        return order
    
    def schedule_production(self, order_id: str) -> bool:
        """为订单安排生产计划"""
        if order_id not in self.orders:
            return False
        
        order = self.orders[order_id]
        
        # 按优先级和截止日期排序，这里简化处理
        # 在实际系统中，需要考虑更多因素
        
        # 为每个步骤安排时间和设备
        current_time = datetime.datetime.now()
        
        for step in order.steps:
            # 计算步骤的最早可能开始时间
            earliest_start = current_time
            
            # 考虑依赖关系
            for dep_id in step.dependencies:
                dep_step = next((s for s in order.steps if s.id == dep_id), None)
                if dep_step and dep_step.end_time:
                    earliest_start = max(earliest_start, dep_step.end_time)
            
            # 找到可用的机器
            assigned = False
            for machine in self.machines.values():
                # 检查机器是否有执行此步骤所需的能力
                if any(capability in step.required_tools for capability in machine.capabilities):
                    if machine.is_available(earliest_start, step.estimated_duration):
                        # 分配时间槽
                        machine.assign_time_slot(order_id, earliest_start, step.estimated_duration)
                        
                        # 更新步骤信息
                        step.start_time = earliest_start
                        step.end_time = earliest_start + datetime.timedelta(minutes=step.estimated_duration)
                        step.status = ProductionStatus.PENDING
                        
                        assigned = True
                        break
            
            if not assigned:
                # 没有找到可用机器，需要推迟或报错
                order.status = ProductionStatus.DELAYED
                return False
        
        order.status = ProductionStatus.PENDING
        return True
    
    def get_production_status(self, order_id: str) -> Optional[Dict]:
        """获取订单生产状态"""
        if order_id not in self.orders:
            return None
        
        order = self.orders[order_id]
        steps_status = []
        
        for step in order.steps:
            steps_status.append({
                "id": step.id,
                "name": step.name,
                "status": step.status.value,
                "start_time": step.start_time.isoformat() if step.start_time else None,
                "end_time": step.end_time.isoformat() if step.end_time else None
            })
        
        return {
            "order_id": order.id,
            "status": order.status.value,
            "deadline": order.deadline.isoformat(),
            "steps": steps_status,
            "assigned_machine": order.assigned_machine
        }
    
    def update_step_status(self, order_id: str, step_id: str, 
                          status: ProductionStatus) -> bool:
        """更新生产步骤状态"""
        if order_id not in self.orders:
            return False
        
        order = self.orders[order_id]
        step = next((s for s in order.steps if s.id == step_id), None)
        
        if not step:
            return False
        
        step.status = status
        
        if status == ProductionStatus.IN_PROGRESS and not step.start_time:
            step.start_time = datetime.datetime.now()
        elif status == ProductionStatus.COMPLETED:
            step.end_time = datetime.datetime.now()
        
        # 检查整个订单是否完成
        if all(s.status == ProductionStatus.COMPLETED for s in order.steps):
            order.status = ProductionStatus.COMPLETED
        
        return True

步骤六：整合系统并创建用户界面

现在，让我们将所有Agent整合在一起，并创建一个简单的Web界面，使用Flask作为后端框架。

# app.py
from flask import Flask, render_template, request, jsonify
from dotenv import load_dotenv
import os
import datetime

# 导入我们之前创建的模块
from requirements_agent import RequirementsUnderstandingAgent, GiftPackageRequirements
from design_library import DesignLibrary, DesignTemplate, Material, MaterialType
from design_generation_agent import DesignGenerationAgent
from design_evaluation_agent import DesignEvaluationAgent
from production_scheduling_agent import ProductionSchedulingAgent, Machine

# 初始化Flask应用
app = Flask(__name__)
load_dotenv()

# 初始化各个组件
openai_api_key = os.getenv("OPENAI_API_KEY")

# 初始化设计库
design_library = DesignLibrary()

# 添加一些示例材料
design_library.add_material(Material(
    id="red_paper_01",
    name="红色包装纸",
    type=MaterialType.PAPER,
    color="红色",
    texture="光滑",
    cost=5.0
))

design_library.add_material(Material(
    id="pink_ribbon_01",
    name="粉色丝带",
    type=MaterialType.RIBBON,
    color="粉色",
    texture="丝绸",
    cost=3.0
))

design_library.add_material(Material(
    id="heart_decoration_01",
    name="心形装饰",
    type=MaterialType.ACCESSORY,
    color="金色",
    cost=2.0
))

# 添加一些示例模板
valentine_template = DesignTemplate(
    id="valentine_simple_01",
    name="情人节简约包装",
    style="浪漫",
    occasion="情人节",
    materials=[
        design_library.materials["red_paper_01"],
        design_library.materials["pink_ribbon_01"],
        design_library.materials["heart_decoration_01"]
    ],
    layout_description="使用红色包装纸为基础，搭配粉色丝绸丝带，在包装顶部添加心形装饰",
    difficulty_level=2,
    estimated_time=30,
    popularity_score=4.5
)

design_library.add_template(valentine_template)

# 初始化Agent
requirements_agent = RequirementsUnderstandingAgent()
design_generation_agent = DesignGenerationAgent(design_library, openai_api_key)
design_evaluation_agent = DesignEvaluationAgent(openai_api_key)
production_agent = ProductionSchedulingAgent()

# 添加一些示例机器
production_agent.add_machine(Machine("packaging_station_1", "包装台1", ["剪刀", "测量工具", "胶带", "包装纸"]))
production_agent.add_machine(Machine("decorating_station_1", "装饰台1", ["胶水", "丝带", "检查清单"]))

# 路由
@app.route('/')
def index():
    return render_template('index.html')

@app.route('/api/parse_requirements', methods=['POST'])
def parse_requirements():
    user_input = request.json.get('description', '')
    try:
        requirements = requirements_agent.parse_requirements(user_input)
        missing_questions = requirements_agent.check_missing_info(requirements)
        
        return jsonify({
            'success': True,
            'requirements': requirements.model_dump(),
            'missing_questions': missing_questions
        })
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 400

@app.route('/api/generate_designs', methods=['POST'])
def generate_designs():
    requirements_data = request.json.get('requirements', {})
    try:
        requirements = GiftPackageRequirements(**requirements_data)
        concepts = design_generation_agent.generate_design_concepts(requirements)
        evaluated_concepts = design_evaluation_agent.evaluate_designs(concepts, requirements)
        
        return jsonify({
            'success': True,
            'concepts': evaluated_concepts
        })
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 400

@app.route('/api/create_order', methods=['POST'])
def create_order():
    concept = request.json.get('concept', {})
    priority = request.json.get('priority', 3)
    deadline_days = request.json.get('deadline_days', 3)
    
    try:
        order = production_agent.create_production_order(concept, priority, deadline_days)
        scheduled = production_agent.schedule_production(order.id)
        
        return jsonify({
            'success': True,
            'order_id': order.id,
            'scheduled': scheduled,
            'deadline': order.deadline.isoformat()
        })
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 400

@app.route('/api/order_status/<order_id>', methods=['GET'])
def get_order_status(order_id):
    status = production_agent.get_production_status(order_id)
    if status:
        return jsonify({'success': True, 'status': status})
    else:
        return jsonify({'success': False, 'error': 'Order not found'}), 404

if __name__ == '__main__':
    app.run(debug=True)

现在，让我们创建一个简单的HTML模板：

<!-- templates/index.html -->
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AI礼品包装定制服务</title>
    <script src="https://cdn.tailwindcss.com"></script>
</head>
<body class="bg-gray-100 min-h-screen">
    <div class="container mx-auto px-4 py-8">
        <h1 class="text-3xl font-bold text-center mb-8 text-gray-800">AI礼品包装定制服务</h1>
        
        <div class="max-w-3xl mx-auto bg-white rounded-lg shadow-md p-6 mb-8">
            <h2 class="text-xl font-semibold mb-4 text-gray-700">描述您的理想礼品包装</h2>
            <textarea id="requirement-input" class="w-full p-3 border border-gray-300 rounded-md mb-4" rows="4" placeholder="例如：我想要一个浪漫风格的情人节礼物包装，用红色和粉色为主色调，加上一些心形元素，包装的是一条项链。"></textarea>
            <button id="parse-btn" class="bg-blue-500 hover:bg-blue-600 text-white font-medium py-2 px-4 rounded-md">解析需求</button>
        </div>
        
        <div id="requirements-section" class="max-w-3xl mx-auto bg-white rounded-lg shadow-md p-6 mb-8 hidden">
            <h2 class="text-xl font-semibold mb-4 text-gray-700">解析后的需求</h2>
            <div id="requirements-display" class="mb-4"></div>
            <div id="missing-info-section" class="mb-4 hidden">
                <h3 class="text-lg font-medium mb-2 text-gray-700">需要补充的信息</h3>
                <div id="missing-info-display"></div>
            </div>
            <button id="generate-designs-btn" class="bg-green-500 hover:bg-green-600 text-white font-medium py-2 px-4 rounded-md">生成设计方案</button>
        </div>
        
        <div id="designs-section" class="max-w-4xl mx-auto hidden">
            <h2 class="text-xl font-semibold mb-4 text-center text-gray-700">推荐设计方案</h2>
            <div id="designs-display" class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6"></div>
        </div>
        
        <div id="order-section" class="max-w-3xl mx-auto bg-white rounded-lg shadow-md p-6 mt-8 hidden">
            <h2 class="text-xl font-semibold mb-4 text-gray-700">订单确认</h2>
            <div id="selected-design-display" class="mb-4"></div>
            <div class="mb-4">
                <label class="block text-gray-700 mb-2">优先级</label>
                <select id="priority-select" class="w-full p-2 border border-gray-300 rounded">
                    <option value="1">普通 (5天)</option>
                    <option value="3" selected>标准 (3天)</option>
                    <option value="5">加急 (1天)</option>
                </select>
            </div>
            <button id="create-order-btn" class="bg-purple-500 hover:bg-purple-600 text-white font-medium py-2 px-4 rounded-md">创建订单</button>
        </div>
        
        <div id="order-status-section" class="max-w-3xl mx-auto bg-white rounded-lg shadow-md p-6 mt-8 hidden">
            <h2 class="text-xl font-semibold mb-4 text-gray-700">订单状态</h2>
            <div id="order-status-display"></div>
        </div>
    </div>

    <script>
        let currentRequirements = null;
        let selectedConcept = null;
        let currentOrderId = null;

        document.getElementById('parse-btn').addEventListener('click', async () => {
            const userInput = document.getElementById('requirement-input').value;
            if (!userInput.trim()) return;
            
            try {
                const response = await fetch('/api/parse_requirements', {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                    },
                    body: JSON.stringify({ description: userInput }),
                });
                
                const data = await response.json();
                if (data.success) {
                    currentRequirements = data.requirements;
                    displayRequirements(data.requirements);
                    displayMissingInfo(data.missing_questions);
                    document.getElementById('requirements-section').classList.remove('hidden');
                }
            } catch (error) {
                console.error('Error parsing requirements:', error);
            }
        });

        document.getElementById('generate-designs-btn').addEventListener('click', async () => {
            if (!currentRequirements) return;
            
            try {
                const response = await fetch('/api/generate_designs', {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                    },
                    body: JSON.stringify({ requirements: currentRequirements }),
                });
                
                const data = await response.json();
                if (data.success) {
                    displayDesigns(data.concepts);
                    document.getElementById('designs-section').classList.remove('hidden');
                }
            } catch (error) {
                console.error('Error generating designs:', error);
            }
        });

        document.getElementById('create-order-btn').addEventListener('click', async () => {
            if (!selectedConcept) return;
            
            const priority = parseInt(document.getElementById('priority-select').value);
            const deadlineDays = priority === 1 ? 5 : (priority === 5 ? 1 : 3);
            
            try {
                const response = await fetch('/api/create_order', {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                    },
                    body: JSON.stringify({ 
                        concept: selectedConcept, 
                        priority: priority,
                        deadline_days: deadlineDays
                    }),
                });
                
                const data = await response.json();
                if (data.success) {
                    currentOrderId = data.order_id;
                    document.getElementById('order-status-section').classList.remove('hidden');
                    updateOrderStatus();
                    // 设置定时更新
                    setInterval(updateOrderStatus, 10000);
                }
            } catch (error) {
                console.error('Error creating order:', error);
            }
        });

        function displayRequirements(requirements) {
            const html = `
                <ul class="list-disc pl-5 space-y-2">
                    <li><strong>场合:</strong> ${requirements.occasion}</li>
                    <li><strong>风格:</strong> ${requirements.style}</li>
                    <li><strong>主色调:</strong> ${requirements.primary_colors.join(', ')}</li>
                    ${requirements.secondary_colors ? `<li><strong>次要颜色:</strong> ${requirements.secondary_colors.join(', ')}</li>` : ''}
                    <li><strong>设计元素:</strong> ${requirements.elements.join(', ')}</li>
                    <li><strong>礼品类型:</strong> ${requirements.gift_type}</li>
                    ${requirements.size ? `<li><strong>尺寸:</strong> ${requirements.size}</li>` : ''}
                    ${requirements.special_requirements ? `<li><strong>特殊要求:</strong> ${requirements.special_requirements}</li>` : ''}
                </ul>
            `;
            document.getElementById('requirements-display').innerHTML = html;
        }

        function displayMissingInfo(questions) {
            const section = document.getElementById('missing-info-section');
            if (questions.length > 0) {
                section.classList.remove('hidden');
                document.getElementById('missing-info-display').innerHTML = `
                    <ul class="list-disc pl-5 space-y-2">
                        ${questions.map(q => `<li>${q}</li>`).join('')}
                    </ul>
                `;
            } else {
                section.classList.add('hidden');
            }
        }

        function displayDesigns(concepts) {
            const container = document.getElementById('designs-display');
            container.innerHTML = concepts.map(concept => `
                <div class="bg-white rounded-lg shadow-md p-4 cursor-pointer hover:shadow-lg transition-shadow" data-concept-id="${concept.concept_id}">
                    <h3 class="text-lg font-semibold mb-2">${concept.name}</h3>
                    <p class="text-gray-600 mb-4">${concept.description}</p>
                    <div class="flex justify-between items-center mb-2">
                        <span class="text-sm bg-blue-100 text-blue-800 px-2 py-1 rounded">综合评分: ${concept.overall_score.toFixed(1)}</span>
                        <span class="text-sm text-gray-500">预计成本: ¥${concept.estimated_cost.toFixed(2)}</span>
                    </div>
                    <div class="flex justify-between items-center">
                        <span class="text-sm text-gray-500">难度: ${'⭐'.repeat(concept.difficulty_level)}</span>
                        <span class="text-sm text-gray-500">预计时间: ${concept.estimated_time}分钟</span>
                    </div>
                    ${concept.suggestions && concept.suggestions.length > 0 ? `
                        <div class="mt-3 p-2 bg-yellow-50 text-yellow-800 text-sm rounded">
                            <strong>改进建议:</strong>
                            <ul class="list-disc pl-4 mt-1">
                                ${concept.suggestions.map(s => `<li>${s}</li>`).join('')}
                            </ul>
                        </div>
                    ` : ''}
                </div>
            `).join('');

            // 添加点击事件
            document.querySelectorAll('#designs-display > div').forEach((element, index) => {
                element.addEventListener('click', () => {
                    // 移除之前选中的样式
                    document.querySelectorAll('#designs-display > div').forEach(el => {
                        el.classList.remove('ring-2', 'ring-purple-500');
                    });
                    // 添加当前选中的样式
                    element.classList.add('ring-2', 'ring-purple-500');
                    
                    selectedConcept = concepts[index];
                    displaySelectedDesign(selectedConcept);
                    document.getElementById('order-section').classList.remove('hidden');
                });
            });
        }

        function displaySelectedDesign(concept