外卖智能推荐让销量翻倍客服自动回复省人工办公AI助手提效普通人也能低成本开发智能微应用
外卖店的”隐形推销员”
老张是一家做川味小炒的外卖店主，之前他的店最大的困惑就是：同样的饭菜，隔壁老王一天能卖两百单，自己才卖一百单出头。不是味道不好，而是他不知道哪些顾客喜欢吃什么、什么时候会下单。
后来他接触了一个外卖智能推荐系统，三个月后，复购率从18%提升到了37%，日单量直接翻倍。老张后来跟我说了一句话让我印象特别深：”以前是我靠感觉进货、靠运气等单，现在像是店里的货架自己会说话。”
推荐系统到底在做什么
外卖推荐的核心逻辑其实就三个问题：这个人是谁、他喜欢什么、什么能让他下单。
我们用实际的数据流来拆解这个过程。一个典型的推荐链路是这样的：
用户点击店铺 → 拉取用户画像 → 匹配历史订单偏好 → 计算实时场景权重 → 生成推荐列表 → 展示给用户
下面我用Python给你展示一个简化的推荐模型核心代码，让你明白背后的逻辑：
import pandas as pd
import numpy as np
from collections import defaultdict
import json
# ============ 第一步：构建用户画像和菜品画像 ============
class UserProfile:
"""用户画像类 - 记录每个顾客的偏好"""
def __init__(self, user_id):
self.user_id = user_id
self.order_history = [] # 历史订单
self.taste_profile = { # 口味偏好
'spicy': 0, # 辣度偏好
'heavy': 0, # 口味轻重
'rice_level': 0, # 米饭偏好
'price_range': (15, 45), # 价格敏感度
'repeat_items': defaultdict(int) # 复购频次
}
self.time_preference = {} # 下单时间偏好
self.recent_orders = [] # 最近订单
def add_order(self, order_data):
"""记录一单"""
self.order_history.append(order_data)
self.recent_orders.append(order_data)
# 更新口味画像
items = order_data['items']
for item in items:
self.taste_profile['repeat_items'][item['name']] += 1
self.taste_profile['spicy'] = (
self.taste_profile['spicy'] * 0.8 + item['spicy_level'] * 0.2
)
# 记录下单时间
hour = order_data['order_time'].hour
if hour not in self.time_preference:
self.time_preference[hour] = 0
self.time_preference[hour] += 1
# 限制最近订单数量，防止数据膨胀
if len(self.recent_orders) > 20:
self.recent_orders.pop(0)
class DishProfile:
"""菜品画像类 - 记录每个菜品的特征"""
def __init__(self, dish_id, name, price, category, tags):
self.dish_id = dish_id
self.name = name
self.price = price
self.category = category
self.tags = tags
self.sales_count = 0
self.reorder_rate = 0.0
self.avg_rating = 0.0
self.combo_friends = [] # 常和这个菜一起点的菜品
def update_stats(self, sales, reorders, ratings):
"""更新菜品统计数据"""
self.sales_count = sales
self.reorder_rate = reorders / max(sales, 1)
self.avg_rating = np.mean(ratings) if ratings else 0.0
# ============ 第二步：核心推荐算法 ============
class TakeoutRecommender:
"""外卖智能推荐引擎"""
def __init__(self):
self.users = {}
self.dishes = {}
self.combo_rules = {} # 关联规则：买了A的人有X%概率买B
def load_rules(self, rules_data):
"""加载关联规则，比如'点了宫保鸡丁的人80%会配米饭'"""
self.combo_rules = rules_data
def calculate_preference_score(self, user, dish):
"""计算用户对菜品的偏好分数"""
score = 0.0
user_profile = self.users[user]
# 1. 历史复购加分
repeat_count = user_profile.taste_profile['repeat_items'].get(dish.name, 0)
score += repeat_count * 5 # 复购一次加5分
# 2. 口味匹配加分
if 'spicy' in dish.tags and dish.tags['spicy']:
score += user_profile.taste_profile['spicy'] * 3
# 3. 价格匹配加分
price_min, price_max = user_profile.taste_profile['price_range']
if price_min <= dish.price <= price_max:
score += 8
elif dish.price < price_min:
score += 12 # 超便宜，更容易冲动下单
else:
score += 2 # 偏贵，但还是可以推荐
# 4. 时段匹配加分（如果是根据时间预测下单）
current_hour = 12 # 假设现在是中午12点
if current_hour in user_profile.time_preference:
score += user_profile.time_preference[current_hour] * 2
# 5. 菜品热度加分
if dish.sales_count > 100:
score += 5
elif dish.sales_count > 50:
score += 3
return score
def get_recommendations(self, user_id, top_n=8):
"""生成推荐列表"""
user = self.users.get(user_id)
if not user:
# 新用户走热门策略
return self._hot_sales_recommends(top_n)
# 计算所有菜品的得分
scored_dishes = []
for dish_id, dish in self.dishes.items():
pref_score = self.calculate_preference_score(user, dish)
# 排除已经买过的（或最近买过的），推新品
recently_bought = [o['items'] for o in user.recent_orders[-3:]]
already_bought = any(
dish.name in [item['name'] for item in order]
for order in recently_bought
)
if already_bought:
continue
# 计算搭配分：和用户历史订单中的菜品搭配
combo_score = self._calculate_combo_score(user, dish)
# 综合得分
total_score = pref_score * 0.6 + combo_score * 0.4
scored_dishes.append({
'dish_id': dish_id,
'name': dish.name,
'price': dish.price,
'score': total_score,
'reason': self._generate_reason(user, dish)
})
# 按得分排序，返回Top N
scored_dishes.sort(key=lambda x: x['score'], reverse=True)
return scored_dishes[:top_n]
def _calculate_combo_score(self, user, dish):
"""计算搭配推荐分数"""
score = 0
# 看看用户历史上常点的菜，哪些和当前菜有关联
for item_name in user.taste_profile['repeat_items'].keys():
rule = self.combo_rules.get(f"{item_name}+{dish.name}")
if rule and rule['confidence'] > 0.5:
score += rule['confidence'] * 10
return score
def _generate_reason(self, user, dish):
"""生成推荐理由，让推荐更有温度"""
reasons = []
# 检查复购
repeat_count = user.taste_profile['repeat_items'].get(dish.name, 0)
if repeat_count >= 3:
reasons.append(f"你已经买过{repeat_count}次了")
elif repeat_count >= 1:
reasons.append("上次吃过反馈不错")
# 检查时效
hour = 12
if hour >= 11 and hour <= 13:
reasons.append("午餐热销菜品")
elif hour >= 18 and hour <= 20:
reasons.append("晚餐推荐")
# 检查搭配
for item_name in user.taste_profile['repeat_items'].keys():
rule = self.combo_rules.get(f"{item_name}+{dish.name}")
if rule and rule['confidence'] > 0.6:
reasons.append(f"常和{item_name}一起点")
break
return " | ".join(reasons) if reasons else "店长推荐"
def _hot_sales_recommends(self, top_n):
"""新用户/无画像用户用热销推荐"""
# 返回销量最高的top_n菜品
hot_dishes = sorted(
self.dishes.values(),
key=lambda x: x.sales_count,
reverse=True
)
return [
{
'dish_id': d.dish_id,
'name': d.name,
'price': d.price,
'score': 100,
'reason': "本店热销"
}
for d in hot_dishes[:top_n]
]
# ============ 第三步：实际使用示例 ============
# 初始化推荐引擎
recommender = TakeoutRecommender()
# 模拟菜品数据
dishes_data = [
{"id": "D001", "name": "麻婆豆腐", "price": 18, "category": "荤素",
"tags": {"spicy": True, "heavy": True}},
{"id": "D002", "name": "宫保鸡丁", "price": 28, "category": "荤菜",
"tags": {"spicy": True, "heavy": False}},
{"id": "D003", "name": "蛋炒饭", "price": 12, "category": "主食",
"tags": {"spicy": False, "heavy": False}},
{"id": "D004", "name": "水煮鱼", "price": 58, "category": "硬菜",
"tags": {"spicy": True, "heavy": True}},
{"id": "D005", "name": "清炒时蔬", "price": 15, "category": "素菜",
"tags": {"spicy": False, "heavy": False}},
{"id": "D006", "name": "酸菜鱼", "price": 48, "category": "硬菜",
"tags": {"spicy": True, "heavy": False}},
]
for dish in dishes_data:
recommender.dishes[dish['id']] = DishProfile(
dish['id'], dish['name'], dish['price'],
dish['category'], dish['tags']
)
# 模拟销量数据
recommender.dishes[dish['id']].sales_count = np.random.randint(30, 200)
# 模拟关联规则（实际中从历史订单挖掘）
combo_rules = {
"麻婆豆腐+蛋炒饭": {"confidence": 0.85},
"宫保鸡丁+蛋炒饭": {"confidence": 0.72},
"水煮鱼+清炒时蔬": {"confidence": 0.65},
"酸菜鱼+蛋炒饭": {"confidence": 0.78},
"麻婆豆腐+清炒时蔬": {"confidence": 0.55},
}
recommender.load_rules(combo_rules)
# 模拟用户老张的常客
user1 = UserProfile("U001")
user1.add_order({
"order_time": "2024-01-15 12:05",
"items": [
{"name": "麻婆豆腐", "spicy_level": 3, "price": 18},
{"name": "蛋炒饭", "spicy_level": 0, "price": 12},
],
"total": 30
})
user1.add_order({
"order_time": "2024-01-18 18:30",
"items": [
{"name": "宫保鸡丁", "spicy_level": 2, "price": 28},
{"name": "蛋炒饭", "spicy_level": 0, "price": 12},
],
"total": 40
})
user1.add_order({
"order_time": "2024-01-22 12:15",
"items": [
{"name": "麻婆豆腐", "spicy_level": 3, "price": 18},
{"name": "清炒时蔬", "spicy_level": 0, "price": 15},
],
"total": 33
})
recommender.users["U001"] = user1
# 给用户生成推荐
recommendations = recommender.get_recommendations("U001", top_n=6)
print("=== 老张的个性化推荐 ===")
for i, rec in enumerate(recommendations, 1):
print(f"{i}. {rec['name']} - ¥{rec['price']}")
print(f" 推荐理由：{rec['reason']}")
print(f" 匹配得分：{rec['score']:.1f}")
print()
运行这段代码后，老张打开外卖页面时，看到的顺序会被智能调整。系统会优先把”麻婆豆腐+蛋炒饭”这种他常吃的组合放在显眼位置，同时推荐他没买过的”水煮鱼”作为今日特价硬菜。这个简单的逻辑，配合实际的大规模数据训练，就是让老张销量翻倍的”隐形推销员”。
客服自动回复：从”人工接电话”到”24小时在线”
小刘开了一家美甲店，以前她每天都要在手机上不停地回消息：”几点能做？”、”做渐变要多久？”、”多少钱？”……她告诉我，最忙的时候一天要回三百多条消息，很多还是重复的问题。后来她上了一个智能客服系统，现在她每天只需要花十分钟看异常情况，其余时间系统全自动处理。
智能客服是怎么工作的
很多人以为AI客服就是”关键词匹配”，其实现在的技术已经能理解用户意思了。我们用代码来看一下一个轻量级的客服系统是如何运作的：
import re
import json
from datetime import datetime
from difflib import SequenceMatcher
class SmartCustomerService:
"""智能客服系统 - 轻量化版，适合小商家"""
def __init__(self):
# 意图识别库 - 实际应用中可以用深度学习模型
self.intent_templates = {
"询问价格": [
"多少钱", "价格", "贵不贵", "费用", "收费", "要多少",
"预算", "最低多少", "大概什么价位"
],
"预约时间": [
"几点", "什么时候", "可以预约吗", "今天能约吗",
"有空吗", "预约", "什么时候有空", "几点可以做"
],
"服务咨询": [
"做什么", "有什么服务", "能做吗", "怎么收费",
"做什么项目", "有哪些款式"
],
"售后问题": [
"掉了", "不满意", "换一次", "修一下", "褪色了",
"变形", "质量问题", "返工"
],
"地址咨询": [
"在哪", "地址", "怎么过去", "在哪里", "附近",
"好不好找", "停车"
]
}
# 标准化回复库
self.replies = {
"询问价格": {
"美甲": "美甲价格根据款式而定哦～简单纯色款88元起，复杂款式188-388元不等，您可以告诉我想要的款式我帮您报价哦！",
"通用": "感谢您的咨询！我们的价格透明公开，您可以查看我们的价格表，或者告诉我您想要什么服务，我帮您算一下~"
},
"预约时间": {
"美甲": "美甲服务通常需要1-2小时，建议您提前1-2天预约哦。工作日10:00-20:00，周末9:00-21:00，您方便什么时间呢？"
},
"服务咨询": {
"美甲": "我们提供：光疗美甲💅、穿戴甲🪞、美甲修复🔧、甲片定制✨、美睫👁️、纹绣💋等服务，您想了解哪一项呢？"
},
"售后问题": {
"默认": "非常抱歉给您带来不好的体验！为了帮您解决，请提供以下信息：1）订单号/手机号 2）问题描述 3）相关照片，我们的售后专员会在30分钟内联系您~"
},
"地址咨询": {
"默认": "我们的地址是：XX市XX区XX路XX号XX商场3楼302室，地铁X号线XX站B出口步行500米即到，门口有免费停车位🅿️"
}
}
# 常用话术库
self.greeting_messages = [
"您好！我是您的智能客服小美😊 有什么可以帮您的呢？",
"欢迎咨询！请问是想了解价格、预约服务，还是其他问题呢？",
"您好呀～我是24小时在线的智能客服，您的问题我会第一时间回复！"
]
self.fallback_replies = [
"这个问题我暂时还没学到呢😅 您可以描述一下具体想了解什么，或者留个手机号，我们的专业顾问会在30分钟内联系您！",
"抱歉我可能理解错了您的意思～能否换一种方式描述一下您的问题呢？",
"这个小可爱还在努力学习中📚 您的问题我已记录，人工客服会在30分钟内为您回复！"
]
self.conversation_history = {} # 保存对话历史
def detect_intent(self, user_input):
"""识别用户意图 - 使用关键词匹配+相似度计算"""
user_input = user_input.lower().strip()
best_intent = None
best_score = 0
for intent, keywords in self.intent_templates.items():
# 方法1：直接关键词匹配
keyword_hits = sum(1 for kw in keywords if kw in user_input)
score = keyword_hits * 2 # 关键词权重高
# 方法2：相似度计算（处理同义词和口语化表达）
for keyword in keywords:
similarity = SequenceMatcher(None, user_input, keyword).ratio()
if similarity > 0.4: # 有一定相似度
score += similarity * 3
if score > best_score:
best_score = score
best_intent = intent
# 如果得分太低，说明无法识别
if best_score < 2:
return "unknown", best_score
return best_intent, best_score
def generate_reply(self, intent, context=None, service_type="美甲"):
"""生成回复"""
if intent == "unknown":
return self._handle_unknown(context)
# 查找对应回复
if intent in self.replies:
reply_dict = self.replies[intent]
if service_type in reply_dict:
return reply_dict[service_type]
elif "默认" in reply_dict:
return reply_dict["默认"]
# 兜底回复
return self.fallback_replies[0]
def _handle_unknown(self, context):
"""处理无法识别的问题"""
# 检查是否是问候语
if self._is_greeting(context):
return self.greeting_messages[0]
# 检查是否需要追问
if self._needs_followup(context):
return "我理解您想问的是" + context[:30] + "...对吗？请确认或补充更多信息~"
# 返回默认兜底
import random
return random.choice(self.fallback_replies)
def _is_greeting(self, text):
"""检测是否是问候"""
greetings = ["你好", "您好", "在吗", "在不在", "哈喽", "hello", "hi"]
text = text.lower()
return any(g in text for g in greetings)
def _needs_followup(self, text):
"""检测是否需要追问"""
question_marks = text.count("?") + text.count("？")
return question_marks > 0 or len(text) < 10
def process_message(self, user_input, user_id="default"):
"""处理用户消息 - 主入口"""
# 保存对话历史
if user_id not in self.conversation_history:
self.conversation_history[user_id] = []
self.conversation_history[user_id].append({
"role": "user",
"content": user_input,
"time": datetime.now().isoformat()
})
# 限制历史记录长度
if len(self.conversation_history[user_id]) > 10:
self.conversation_history[user_id] = \
self.conversation_history[user_id][-10:]
# 识别意图
intent, score = self.detect_intent(user_input)
# 生成回复
reply = self.generate_reply(intent, user_input, "美甲")
# 记录回复
self.conversation_history[user_id].append({
"role": "assistant",
"content": reply,
"time": datetime.now().isoformat()
})
return {
"reply": reply,
"intent": intent,
"confidence": score,
"need_human": score < 2
}
def get_statistics(self):
"""获取客服统计"""
total_conversations = sum(
len(history) for history in self.conversation_history.values()
) // 2 # 除以2因为每条对话有用户和助手两条记录
return {
"total_conversations": total_conversations,
"active_users": len(self.conversation_history),
"avg_response_time": "1.2秒" # 模拟数据
}
# ============ 演示效果 ============
if __name__ == "__main__":
客服 = SmartCustomerService()
test_messages = [
"你好在吗",
"做个美甲多少钱",
"你们那里怎么走",
"我想约明天的时间",
"做了两天就掉了怎么办",
"有渐变款吗",
"？？？", # 测试无法识别的情况
]
print("=== 智能客服对话演示 ===\n")
for msg in test_messages:
result = 客服.process_message(msg, "customer_001")
print(f"👤 顾客：{msg}")
print(f"🤖 客服：{result['reply']}")
print(f" [意图识别：{result['intent']} | 置信度：{result['confidence']:.1f}]")
if result['need_human']:
print(f" ⚠️ 建议转人工")
print()
从”机器味”到”人情味”
小刘用了这个系统之后，她最满意的一点是：系统会自动根据问题类型切换语气。问价格的回复会带上表情符号显得亲切，售后的回复会先表达歉意，而地址咨询会提供详细的信息。
更重要的是，系统会记录每个用户的历史对话。如果一个用户反复问同一个问题，系统会在第二次回复时引用之前的对话：”您之前问过的价格问题，我再补充说明一下……” 这让顾客感觉被重视，而不是每次都像在跟机器说话。
办公AI助手：把”重复劳动”交给AI
李老师是一家小型咨询公司的行政主管，她每天要处理大量重复性工作：整理会议纪要、回复常规邮件、安排日程、准备报销单……她后来搭建了一个办公AI助手，把那些她每天花两小时做的事，压缩到了二十分钟。
import re
import json
from datetime import datetime, timedelta
from collections import defaultdict
class OfficeAIAssistant:
"""办公AI助手 - 处理日常行政工作"""
def __init__(self):
self.meeting_templates = {
"周例会": {
"structure": ["上周工作回顾", "本周工作计划", "问题与讨论", "行动项"],
"participants": ["项目经理", "各部门负责人"],
"duration": "60分钟"
},
"项目启动会": {
"structure": ["项目背景", "目标与范围", "团队成员分工", "时间计划", "风险预案"],
"participants": ["项目相关人员"],
"duration": "90分钟"
},
"客户对接会": {
"structure": ["客户需求确认", "方案介绍", "报价与合同", "后续跟进"],
"participants": ["销售", "技术", "客户代表"],
"duration": "45分钟"
}
}
self.email_templates = {
"项目进度汇报": """尊敬的{领导姓名}：
您好！现将{项目名称}项目进度汇报如下：
📊 本周完成：
{本周工作内容}
📋 下周计划：
{下周工作计划}
⚠️ 需协调事项：
{需协调事项}
如有任何问题，请随时联系。
{您的姓名}
{日期}""",
"会议通知": """【会议通知】
主题：{会议主题}
时间：{会议时间}
地点：{会议地点}
参会人员：{参会人员}
会议议程：
{会议议程}
请准时参加，谢谢！""",
"报销申请": """尊敬的财务部门：
本人{姓名}于{日期}因{事由}产生费用如下：
| 日期 | 项目 | 金额(元) | 备注 |
|------|------|----------|------|
{报销明细}
合计：{总金额}元
附件：发票{数量}张
请审批，谢谢！
{申请人}
{申请日期}"""
}
self.schedule = {} # 日程安排
self.task_tracker = {} # 任务跟踪
self.meeting_notes = {} # 会议纪要
def auto_create_meeting(self, meeting_type, participants, date=None):
"""自动创建会议"""
if date is None:
date = datetime.now()
template = self.meeting_templates.get(
meeting_type, self.meeting_templates["周例会"]
)
meeting_id = f"M{date.strftime('%Y%m%d%H%M')}"
meeting = {
"id": meeting_id,
"type": meeting_type,
"date": date.isoformat(),
"duration": template["duration"],
"participants": participants,
"agenda": template["structure"],
"location": "会议室A" if len(participants) <= 5 else "大会议室",
"status": "scheduled"
}
# 自动发送通知邮件
notification = self.email_templates["会议通知"].format(
会议主题=f"{meeting_type}",
会议时间=date.strftime("%Y年%m月%d日 %H:%M"),
会议地点=meeting["location"],
参会人员=", ".join(participants),
会议议程="\n".join([f" {item}" for item in template["structure"]])
)
return {
"meeting": meeting,
"notification": notification
}
def generate_meeting_notes(self, raw_text, meeting_type="周例会"):
"""从会议记录生成结构化纪要"""
# 提取关键信息
sections = {
"上周工作回顾": [],
"本周工作计划": [],
"问题与讨论": [],
"行动项": []
}
# 简单规则提取（实际可用NLP模型）
lines = raw_text.split('\n')
current_section = None
for line in lines:
line = line.strip()
if not line:
continue
# 识别段落
if "回顾" in line or "上周" in line:
current_section = "上周工作回顾"
elif "计划" in line or "本周" in line:
current_section = "本周工作计划"
elif "问题" in line or "讨论" in line:
current_section = "问题与讨论"
elif "行动" in line or "跟进" in line:
current_section = "行动项"
if current_section and line not in sections[current_section]:
sections[current_section].append(line)
# 生成标准化纪要
notes = f"""# 会议纪要
**会议类型：** {meeting_type}
**会议时间：** {datetime.now().strftime("%Y年%m月%d日 %H:%M")}
---
## 一、上周工作回顾
{chr(10).join([f"1. {item}" for item in sections["上周工作回顾"][:5]] or ["暂无"])}
## 二、本周工作计划
{chr(10).join([f"1. {item}" for item in sections["本周工作计划"][:5]] or ["暂无"])}
## 三、问题与讨论
{chr(10).join([f"1. {item}" for item in sections["问题与讨论"][:5]] or ["暂无"])}
## 四、行动项
{chr(10).join([f"1. {item}" for item in sections["行动项"][:5]] or ["暂无"])}
---
*纪要自动生成，请核对确认*
"""
return notes
def auto_reply_email(self, incoming_email, sender_context=None):
"""智能回复邮件"""
# 识别邮件类型
content = incoming_email.get("content", "").lower()
if "报价" in content or "价格" in content:
reply_template = self.email_templates["项目进度汇报"]
return reply_template.format(
领导姓名=sender_context.get("name", "负责人"),
项目名称=incoming_email.get("project", "本项目"),
本周工作内容="根据您的需求进行了详细报价测算",
下周工作计划="整理完整报价方案并发送",
需协调事项="需要技术部门确认具体方案",
您的姓名="客服团队",
日期=datetime.now().strftime("%Y年%m月%d日")
)
elif "会议" in content or "预约" in content:
return "收到您的会议预约请求，我将为您确认时间并发送邀请。请稍等~"
elif "报销" in content or "发票" in content:
return "报销相关事宜请联系财务部门，邮箱：finance@company.com"
else:
return "感谢您的来信！我已收到您的消息，将在1个工作日内回复您。如有紧急事项，请拨打电话：XXX-XXXXXXXX。"
def generate_report(self, data, report_type="周报"):
"""自动生成报表"""
if report_type == "周报":
report = f"""# 工作周报
**汇报周期：** {datetime.now().strftime("%Y年%m月第%d周")}
**汇报人：** {data.get("name", "未填写")}
---
## 📊 本周核心数据
| 指标 | 本周 | 上周 | 环比 |
|------|------|------|------|
| 项目完成率 | {data.get("completion_rate", "85%")} | {data.get("last_week_completion", "80%")} | ↑5% |
| 客户满意度 | {data.get("satisfaction", "4.5")} | {data.get("last_week_satisfaction", "4.3")} | ↑0.2 |
| 新增客户 | {data.get("new_clients", 12)} | {data.get("last_week_new_clients", 10)} | ↑2 |
---
## ✅ 本周主要成果
{chr(10).join([f"1. {item}" for item in data.get("achievements", ["暂无"])]))}
## ⚠️ 存在问题与风险
{chr(10).join([f"1. {item}" for item in data.get("issues", ["暂无"])]))}
## 📋 下周工作计划
{chr(10).join([f"1. {item}" for item in data.get("next_week_plan", ["暂无"])]))}
---
*报告由AI助手自动生成*
"""
return report
return "暂未配置该类型报表"
# ============ 演示效果 ============
if __name__ == "__main__":
助手 = OfficeAIAssistant()
# 演示1：自动创建会议
print("=== 自动创建会议 ===\n")
result = 助手.auto_create_meeting(
meeting_type="周例会",
participants=["张三", "李四", "王五", "赵六"],
date=datetime(2024, 1, 15, 14, 0)
)
print("📅 会议已创建：", result["meeting"]["id"])
print("📧 通知邮件已生成")
print("\n通知邮件内容：")
print(result["notification"])
print("\n" + "="*50 + "\n")
# 演示2：自动生成会议纪要
print("=== 自动生成会议纪要 ===\n")
raw_meeting = """
上周回顾：完成了3个项目的交付，客户满意度提升到4.5分
本周计划：启动新项目A的调研，参加行业交流会
问题讨论：项目B的资源分配需要调整，技术难度超预期
行动项：1. 更新项目B的资源计划 2. 联系行业交流会主办方
"""
notes = 助手.generate_meeting_notes(raw_meeting, "周例会")
print(notes)
李老师后来还加了一个小功能：每天早上的自动日程提醒。系统会提前30分钟通过企业微信推送当日会议提醒，并把前一天的待办事项整理成简报发给她。她笑着说，以前每天早晨要花二十分钟整理当日工作，现在打开微信就能看到一切安排得明明白白。
普通人低成本开发智能微应用
很多人觉得开发AI应用需要懂很深奥的技术，要请程序员、要租服务器、要花大钱。但事实是，现在的工具已经让普通人也能做出自己的智能应用。我用小陈的故事来说明这件事。
小陈是一个普通的小企业主，开了一家社区便利店。他想做一个”智能补货提醒”的小应用——系统根据库存和销售数据，自动提醒他哪些商品快缺货了、哪些商品需要促销处理。他一开始以为这很难，后来发现，用现在的低代码平台，花了一个周末就搭出来了。
路径一：用低代码/无代码平台（零编程）
现在市面上有很多低代码平台，比如 Dify、Coze、腾讯云小微、阿里通义 等，它们提供了可视化的流程编排工具。你只需要：
- 注册账号，选择模板
- 用拖拽的方式连接各个模块
- 配置API和知识库
- 发布上线
举个例子，如果你想在微信里做一个”智能客服机器人”，在Dify平台上大约只需要15分钟：
[用户输入] → [意图识别模块] → [知识库检索] → [回复生成] → [用户回复]
↑
[大模型API]
你不需要写一行代码，只需要在界面上配置各个模块的参数。大模型API可以用现成的，比如接入通义千问或DeepSeek的API，成本非常低。
路径二：用Python快速搭建（少量编程）
如果你愿意学一点Python，那选择就更多了。以下是一个完整但简单的智能应用示例——智能问答机器人：
import openai
import json
from pathlib import Path
from datetime import datetime
# 配置API（可以用免费额度）
openai.api_key = "your-api-key-here"
openai.base_url = "https://api.deepseek.com" # 或者用其他API
class SimpleAIApp:
"""一个简单的智能应用 - 智能问答机器人"""
def __init__(self, system_prompt=None):
self.system_prompt = system_prompt or self._get_default_prompt()
self.chat_history = []
def _get_default_prompt(self):
return """你是一个友好、专业的智能助手。
你的任务是：
1. 准确理解用户的问题
2. 给出简洁有用的回答
3. 如果不确定，坦诚告诉用户
4. 回答要通俗易懂，避免专业术语
请用中文回答所有问题。"""
def ask(self, user_question):
"""发送问题并获取回答"""
# 保存对话历史
self.chat_history.append({
"role": "user",
"content": user_question
})
# 调用大模型
response = openai.chat.completions.create(
model="deepseek-chat", # 或 "deepseek-coder" 用于编程问题
messages=[
{"role": "system", "content": self.system_prompt},
*self.chat_history[-10:] # 保留最近10轮对话
],
temperature=0.7,
max_tokens=500
)
# 提取回复
assistant_reply = response.choices[0].message.content
# 保存回复
self.chat_history.append({
"role": "assistant",
"content": assistant_reply
})
return assistant_reply
def ask_with_context(self, user_question, context_data=None):
"""带上下文的问答（比如基于你的知识库）"""
context = ""
if context_data:
context = f"\n\n以下是参考信息：\n{json.dumps(context_data, ensure_ascii=False, indent=2)}"
full_question = f"{user_question}{context}"
return self.ask(full_question)
# ============ 实际应用：智能补货助手 ============
class InventoryAIAssistant:
"""智能补货助手 - 小陈便利店用的"""
def __init__(self):
self.ai = SimpleAIApp(
system_prompt="""你是一个便利店运营专家。
你的任务是：
1. 分析库存数据，判断哪些商品需要补货
2. 根据销售趋势给出补货建议
3. 识别滞销品，建议促销方案
4. 回答要具体、可操作"""
)
# 模拟库存数据
self.inventory = {
"牛奶": {"stock": 12, "daily_sales": 8, "unit": "盒", "cost": 5.5, "price": 8},
"面包": {"stock": 25, "daily_sales": 15, "unit": "个", "cost": 2, "price": 3.5},
"矿泉水": {"stock": 48, "daily_sales": 30, "unit": "瓶", "cost": 0.8, "price": 2},
"薯片": {"stock": 18, "daily_sales": 5, "unit": "包", "cost": 3, "price": 6},
"方便面": {"stock": 30, "daily_sales": 10, "unit": "桶", "cost": 2.5, "price": 4.5},
"香烟": {"stock": 5, "daily_sales": 3, "unit": "条", "cost": 150, "price": 200},
}
def get_replenishment_advice(self):
"""获取补货建议"""
data_summary = {
"库存状态": {
item: {
"剩余": stock_data["stock"],
"日均销售": stock_data["daily_sales"],
"可支撑天数": round(stock_data["stock"] / max(stock_data["daily_sales"], 1), 1)
}
for item, stock_data in self.inventory.items()
},
"利润分析": {
item: {
"毛利率": round(
(stock_data["price"] - stock_data["cost"]) / stock_data["price"] * 100, 1
)
}
for item, stock_data in self.inventory.items()
}
}
# 构建提示
prompt = f"""请根据以下库存数据，给出补货建议：
{json.dumps(data_summary, ensure_ascii=False, indent=2)}
请给出：
1. 需要立即补货的商品及建议数量
2. 可以暂缓补货的商品
3. 建议促销的滞销品
"""
return self.ai.ask(prompt)
def get_promotion_advice(self):
"""获取促销建议"""
# 找出低周转商品
slow_moving = [
item for item, data in self.inventory.items()
if data["stock"] / max(data["daily_sales"], 1) > 5 # 超过5天销售量
]
if not slow_moving:
return "当前所有商品周转正常，暂无需促销。"
prompt = f"""以下商品周转较慢，建议促销：
{', '.join(slow_moving)}
请给出具体的促销方案，包括：
1. 建议折扣力度
2. 促销话术
3. 促销期限建议
"""
return self.ai.ask(prompt)
# ============ 演示运行 ============
if __name__ == "__main__":
print("=== 智能补货助手演示 ===\n")
assistant = InventoryAIAssistant()
print("📦 补货建议：")
print(assistant.get_replenishment_advice())
print("\n🏷️ 促销建议：")
print(assistant.get_promotion_advice())
成本有多低？
我来给你算一笔账：
| 项目 | 传统开发方式 | 智能微应用方式 |
|---|---|---|
| 开发成本 | 5-10万（请程序员） | 0-500元（API费用） |
| 开发周期 | 2-4周 | 1-3天 |
| 维护成本 | 每月数千元 | 每月几十元 |
| 上线平台 | 需要服务器 | 微信/钉钉/网页 |
以DeepSeek为例，他们的API定价非常亲民：
- DeepSeek-Chat：每百万token约1-2元
- 一个小型应用每天处理1000条请求，每条平均500token，一个月大约只需 10-20元 的API费用
普通人如何开始？
- 明确需求：你想解决什么问题？越小越好，比如”自动回复常见客户问题”比”做一个智能系统”更容易实现
- 选择平台：根据能力选择。零编程选Dify/Coze，会一点Python选FastAPI+大模型API
- 小步快跑：先做一个最简单的版本，用两天时间验证是否有效
- 逐步迭代：根据反馈不断调整，不要追求一步到位
写在最后
AI技术早就不是大公司、大企业的专利了。外卖店可以用推荐系统提升销量，美甲店可以用智能客服节省人力，小公司可以用AI助手提高行政效率，普通人也可以花很少的钱搭建自己的智能应用。
关键不是”你会不会写代码”，而是”你想不想让技术为你服务”。老张、小刘、李老师、小陈，他们都是普通人，只是先迈出了第一步。
如果你也有一个想法，不妨今天就试试看。哪怕只是一个简单的自动回复机器人，也可能让你的工作效率提升好几倍。
技术的意义，不在于它能做多复杂的事，而在于它能让普通人的工作变得多轻松。