Agno开发教程系列（三）：Agent的记忆系统——让AI记住你
本教程是Agno框架系列教程的第三篇，将深入讲解如何为AI Agent添加记忆功能，让你的智能助手真正"记住"用户的偏好和历史交互。
📖 目录
引言：为什么AI需要记忆？
想象一下，你每次见到朋友时，他都不记得你的名字、你们之前的对话，甚至不记得你喜欢什么。这样的交流该有多令人沮丧！
对于AI Agent来说，情况也是一样的。没有记忆的AI Agent就像患了健忘症的助手：
❌ 没有记忆的Agent：
用户："嗨，我叫张三，我喜欢喝咖啡。"
Agent："好的，了解了！"
（5分钟后）
用户："你还记得我喜欢什么吗？"
Agent："抱歉，我不知道您的偏好。"
✅ 有记忆的Agent：
用户："嗨，我叫张三，我喜欢喝咖啡。"
Agent："你好张三！我记住了，你喜欢咖啡。"
（5分钟后，甚至第二天）
用户："你还记得我喜欢什么吗？"
Agent："当然记得！张三，你喜欢喝咖啡。需要我推荐附近的咖啡店吗？"
记忆系统的核心价值：
- 上下文连续性 - 理解对话的前因后果
- 个性化服务 - 基于用户历史提供定制化响应
- 任务追踪 - 记住长期任务的进度和状态
- 学习和改进 - 从过去的交互中学习，不断优化服务
- 用户体验提升 - 让用户感到被理解和重视
在本教程中，我们将学习如何使用Agno框架构建具有强大记忆能力的AI Agent！
记忆系统的基本概念
在深入代码之前，让我们先了解AI Agent记忆系统的基本概念。就像人类大脑一样，AI Agent也需要不同类型的记忆来处理各种任务。
🧠 记忆类型对比
1. 短期记忆（Buffer Memory）
就像你的工作台，只保留当前对话的最近几轮信息。
特点：
- ⚡ 访问速度快
- 💾 存储容量小
- ⏱️ 会话结束后清空
- 💡 适合单次对话
应用场景： 在线客服处理当前咨询问题
2. 长期记忆（Long-Term Memory）
就像你的档案柜，永久存储重要信息，跨会话使用。
特点：
- 🗄️ 持久化存储（数据库）
- 🔍 可检索、更新、删除
- 🌍 跨会话可用
- 📈 支持大规模数据
应用场景： 记住用户的姓名、偏好、历史订单
3. 语义记忆（Semantic Memory）
通过向量嵌入实现的智能搜索，找到最相关的记忆。
特点：
- 🎯 基于相似度检索
- 🔬 使用向量嵌入技术
- 📚 适合大量非结构化数据
- 🧩 支持模糊匹配
应用场景： 研究助手从数千篇论文中找到相关内容
📊 记忆类型对比表
| 记忆类型 | 存储位置 | 持久性 | 访问速度 | 适用场景 |
|---|---|---|---|---|
| 短期记忆 | 内存 | 临时 | ⚡⚡⚡ 极快 | 单次对话 |
| 长期记忆 | 数据库 | 永久 | ⚡⚡ 快 | 跨会话个性化 |
| 语义记忆 | 向量数据库 | 永久 | ⚡ 较快 | 知识检索 |
🆚 Agno中的核心区分
在Agno框架中，有一个重要的概念区分：
记忆（Memory） ≠ 会话历史（Conversation History）
📝 会话历史：存储对话消息本身
问题："我们刚才讨论了什么？"
💾 记忆：存储从对话中学习到的事实
事实："用户张三喜欢喝咖啡"
理解这个区别很重要！记忆是关于"学到了什么"，而会话历史是关于"说了什么" 。
Agno中的记忆实现方法
Agno框架提供了两种主要的记忆管理方式，让我们逐一了解。
方式一：自动记忆管理（推荐新手使用）
工作原理： Agent在每次对话后，自动提取关键信息并存储，需要时自动检索。
配置方法：
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.db.sqlite import SqliteDb
# 创建数据库连接
db = SqliteDb(db_file="my_agent.db")
# 启用自动记忆
agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_user_memories=True, # 开启自动记忆 ✨
)
优点：
- ✅ 无需手动干预
- ✅ 可靠且可预测
- ✅ 适合大多数场景
- ✅ 学习曲线平缓
推荐场景： 客服机器人、个人助理、教育辅导等需要一致记忆行为的应用
方式二：Agentic记忆管理（高级用法）
工作原理： Agent获得记忆管理工具，可以自主决定何时创建、更新或删除记忆。
配置方法：
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.db.sqlite import SqliteDb
# 创建数据库连接
db = SqliteDb(db_file="my_agent.db")
# 启用Agentic记忆
agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_agentic_memory=True, # Agent自主控制记忆 🤖
)
优点：
- ✅ 精细化控制
- ✅ Agent可推理决策
- ✅ 适合复杂工作流
- ✅ 高度灵活
推荐场景： 复杂多轮对话、需要智能判断的应用、多任务协作
⚠️ 重要提醒： 不要同时启用两种记忆模式！如果同时开启，Agentic记忆会覆盖自动记忆。
🗄️ 支持的数据库
Agno支持多种数据库系统，根据你的需求选择：
| 数据库 | 适用场景 | 特点 |
|---|---|---|
| SQLite | 本地开发、小型应用 | 轻量、无需配置、单文件 |
| PostgreSQL | 生产环境、大规模应用 | 强大、可扩展、支持高并发 |
| MongoDB | 灵活数据结构 | NoSQL、文档存储 |
| ChromaDB | 语义搜索 | 向量数据库、AI原生 |
| FAISS | 高性能检索 | Facebook开源、超快速度 |
初学者建议： 从SQLite开始，简单易用，无需额外配置！
完整代码示例：从简单到复杂
现在，让我们通过一系列实际代码示例来掌握Agno的记忆系统。
示例1：最简单的记忆Agent（5行代码）
让我们从最基础的开始，创建一个能记住用户信息的聊天机器人。
"""
示例1：基础记忆Agent
功能：记住用户的姓名和偏好
"""
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.db.sqlite import SqliteDb
# 步骤1：创建数据库（会在当前目录生成 agent_memory.db 文件）
db = SqliteDb(db_file="agent_memory.db")
# 步骤2：创建支持记忆的Agent
agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"), # 使用DeepSeek模型
db=db, # 连接数据库
enable_user_memories=True, # 启用自动记忆
description="你是一个友好的AI助手，善于记住用户的偏好。"
)
# 步骤3：第一次对话 - Agent会自动记住这些信息
agent.print_response(
"你好！我叫李明，我喜欢喝咖啡，周末喜欢爬山。",
user_id="user_001" # 指定用户ID，用于区分不同用户
)
# 步骤4：稍后的对话 - Agent会自动回忆起之前的信息
agent.print_response(
"你还记得我的爱好吗？",
user_id="user_001"
)
# 步骤5：再次询问 - 测试记忆的准确性
agent.print_response(
"推荐一个适合我周末的活动吧！",
user_id="user_001"
)
运行效果：
👤 用户："你好！我叫李明，我喜欢喝咖啡，周末喜欢爬山。"
🤖 Agent："你好李明！很高兴认识你。我记住了，你喜欢咖啡和周末爬山。有什么我可以帮助你的吗？"
👤 用户："你还记得我的爱好吗？"
🤖 Agent："当然记得！李明，你喜欢喝咖啡，并且周末喜欢爬山。"
👤 用户："推荐一个适合我周末的活动吧！"
🤖 Agent："根据你喜欢爬山的兴趣，我推荐你可以去附近的香山或者十三陵，早上出发前可以先喝杯咖啡提神！"
🎯 关键点：
user_id参数很重要，用于区分不同用户的记忆- Agent会自动提取"姓名"、"喜好"等关键信息
- Agent会自动检索相关记忆并应用到回答中
示例2：自定义记忆表和多用户管理
在实际应用中，你可能需要为不同的业务场景使用不同的记忆存储表。
"""
示例2：多用户记忆管理
功能：支持多个用户，每个用户有独立的记忆
"""
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.db.sqlite import SqliteDb
# 使用自定义表名存储记忆
db = SqliteDb(
db_file="customer_service.db",
memory_table="customer_memories" # 自定义记忆表名
)
# 创建客服Agent
customer_service_agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_user_memories=True,
description="你是一个专业的客服人员，记住每位客户的需求和问题。"
)
# 模拟三位不同的客户
print("=" * 50)
print("客户A的咨询")
print("=" * 50)
customer_service_agent.print_response(
"我是客户A，我购买了iPhone 15，遇到了充电慢的问题。",
user_id="customer_A"
)
print("\n" + "=" * 50)
print("客户B的咨询")
print("=" * 50)
customer_service_agent.print_response(
"你好，我是客户B，我想咨询MacBook的保修政策。",
user_id="customer_B"
)
print("\n" + "=" * 50)
print("客户A再次咨询")
print("=" * 50)
customer_service_agent.print_response(
"你还记得我之前的问题吗？现在情况如何？",
user_id="customer_A"
)
print("\n" + "=" * 50)
print("客户B再次咨询")
print("=" * 50)
customer_service_agent.print_response(
"关于我之前问的问题，能详细说明一下吗？",
user_id="customer_B"
)
运行效果：
==================================================
客户A的咨询
==================================================
🤖 "了解了，客户A。您购买的iPhone 15出现充电慢的问题。
让我帮您排查：请问您使用的是原装充电器吗？..."
==================================================
客户B的咨询
==================================================
🤖 "您好，客户B！MacBook的标准保修期是一年，
您可以选择购买AppleCare+延保服务..."
==================================================
客户A再次咨询
==================================================
🤖 "当然记得！您是客户A，之前反馈iPhone 15充电慢的问题。
请问现在使用原装充电器后情况有改善吗？"
==================================================
客户B再次咨询
==================================================
🤖 "好的，关于MacBook保修政策，标准保修覆盖硬件故障..."
🎯 关键点：
- 通过
user_id区分不同用户 - 每个用户的记忆相互独立
- 自定义
memory_table可以实现业务隔离
示例3：手动管理记忆（高级用法）
有时候你需要更精细的控制，比如手动添加、检索或删除记忆。
"""
示例3：手动记忆管理
功能：程序化地添加、检索、更新和删除记忆
"""
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.db.sqlite import SqliteDb
# 创建数据库和Agent
db = SqliteDb(db_file="manual_memory.db")
agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_user_memories=True
)
# 1️⃣ 手动添加记忆（例如从现有用户数据库导入）
print("=" * 50)
print("步骤1：手动添加用户偏好记忆")
print("=" * 50)
# 模拟从用户数据库读取的信息
user_preferences = {
"name": "王芳",
"favorite_food": "川菜",
"hobby": "摄影",
"occupation": "平面设计师"
}
# 使用Agent的一次对话来创建记忆
agent.print_response(
f"我是{user_preferences['name']}，我喜欢{user_preferences['favorite_food']}，"
f"爱好是{user_preferences['hobby']}，职业是{user_preferences['occupation']}。",
user_id="user_wangfang"
)
# 2️⃣ 检索用户的所有记忆
print("\n" + "=" * 50)
print("步骤2：检索用户的所有记忆")
print("=" * 50)
memories = agent.get_user_memories(user_id="user_wangfang")
if memories:
print(f"找到 {len(memories)} 条记忆：")
for i, memory in enumerate(memories, 1):
print(f"\n记忆 #{i}:")
print(f" - ID: {memory.memory_id}")
print(f" - 内容: {memory.memory}")
print(f" - 主题: {memory.topics}")
print(f" - 更新时间: {memory.updated_at}")
else:
print("未找到记忆")
# 3️⃣ 测试记忆是否生效
print("\n" + "=" * 50)
print("步骤3：测试记忆效果")
print("=" * 50)
agent.print_response(
"根据我的职业和爱好，推荐一个适合我的周末活动。",
user_id="user_wangfang"
)
# 4️⃣ 删除特定记忆（可选）
print("\n" + "=" * 50)
print("步骤4：演示删除记忆（实际使用时谨慎操作）")
print("=" * 50)
if memories and len(memories) > 0:
memory_to_delete = memories[0]
print(f"准备删除记忆: {memory_to_delete.memory}")
# 取消注释以下行来实际删除
# agent.delete_user_memory(
# memory_id=memory_to_delete.memory_id,
# user_id="user_wangfang"
# )
# print("✅ 记忆已删除")
print("⚠️ 删除代码已注释，防止误操作")
运行效果：
==================================================
步骤1：手动添加用户偏好记忆
==================================================
🤖 "你好王芳！很高兴认识你这位平面设计师。
我记住了你喜欢川菜和摄影..."
==================================================
步骤2：检索用户的所有记忆
==================================================
找到 4 条记忆：
记忆 #1:
- ID: mem_abc123
- 内容: 用户名叫王芳
- 主题: ['姓名', '身份']
- 更新时间: 1735564800
记忆 #2:
- ID: mem_def456
- 内容: 喜欢吃川菜
- 主题: ['饮食偏好']
- 更新时间: 1735564800
记忆 #3:
- ID: mem_ghi789
- 内容: 爱好是摄影
- 主题: ['兴趣爱好']
- 更新时间: 1735564800
记忆 #4:
- ID: mem_jkl012
- 内容: 职业是平面设计师
- 主题: ['职业', '工作']
- 更新时间: 1735564800
==================================================
步骤3：测试记忆效果
==================================================
🤖 "根据你作为平面设计师的职业和摄影爱好，
我推荐你可以去艺术展览或者摄影主题的周末活动..."
🎯 关键点：
get_user_memories()方法检索用户的所有记忆- 每条记忆包含：ID、内容、主题、时间戳等元数据
- 可以通过
delete_user_memory()删除特定记忆 - 记忆会自动按主题分类（如"姓名"、"饮食偏好"等）
示例4：使用PostgreSQL的生产级配置
当你的应用需要部署到生产环境时，建议使用PostgreSQL这样的企业级数据库。
"""
示例4：生产环境配置（PostgreSQL）
功能：使用PostgreSQL数据库，支持高并发和大规模数据
"""
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.db.postgres import PostgresDb
# 配置PostgreSQL数据库
# 实际使用时，建议将数据库URL存储在环境变量中
db = PostgresDb(
db_url="postgresql://username:password@localhost:5432/agno_production",
memory_table="user_memories" # 自定义表名
)
# 创建生产级Agent
production_agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_user_memories=True,
description="生产环境的AI客服助手",
# 额外的生产环境配置
debug_mode=False, # 关闭调试模式
)
# 使用方式与SQLite完全相同
production_agent.print_response(
"我是新用户，想了解你们的产品。",
user_id="prod_user_001"
)
# 后续查询会自动使用记忆
production_agent.print_response(
"我之前咨询过什么？",
user_id="prod_user_001"
)
print("\n✅ 生产环境配置完成！")
print("📌 建议：")
print(" 1. 使用环境变量存储数据库凭证")
print(" 2. 配置数据库连接池")
print(" 3. 定期备份记忆数据")
print(" 4. 设置记忆数据的过期策略")
环境变量配置建议（使用 .env 文件）：
# .env 文件
DEEPSEEK_API_KEY=your_api_key_here
DATABASE_URL=postgresql://username:password@localhost:5432/agno_production
# 使用 python-dotenv 加载环境变量
import os
from dotenv import load_dotenv
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.db.postgres import PostgresDb
load_dotenv() # 加载 .env 文件
db = PostgresDb(
db_url=os.getenv("DATABASE_URL"),
memory_table="user_memories"
)
agent = Agent(
model=DeepSeek(api_key=os.getenv("DEEPSEEK_API_KEY")),
db=db,
enable_user_memories=True
)
示例5：高级用法 - 自定义MemoryManager
对于有特殊需求的场景，你可以完全自定义记忆管理器的行为。
"""
示例5：自定义MemoryManager
功能：定制记忆提取规则、隐私保护、记忆过滤
"""
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.db.sqlite import SqliteDb
from agno.memory import MemoryManager
# 创建数据库
db = SqliteDb(db_file="custom_memory.db")
# 自定义MemoryManager
custom_memory_manager = MemoryManager(
db=db,
model=DeepSeek(api_key="DEEPSEEK_API_KEY"), # 指定用于记忆提取的模型
# 自定义记忆提取指令
memory_capture_instructions="""
从对话中提取以下类型的信息作为记忆：
1. 用户的基本信息（姓名、职业等）
2. 用户的偏好和兴趣
3. 用户的目标和需求
不要提取：
- 敏感个人信息（身份证号、电话号码）
- 密码或安全问题答案
- 财务信息
""",
# 额外的隐私保护指令
additional_instructions="绝不存储用户的真实姓名，使用昵称或代号代替。",
debug_mode=True # 开启调试，查看记忆提取过程
)
# 使用自定义MemoryManager创建Agent
privacy_agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
memory_manager=custom_memory_manager, # 使用自定义记忆管理器
enable_user_memories=True,
description="注重隐私保护的AI助手"
)
# 测试隐私保护
print("=" * 50)
print("测试：提供敏感信息")
print("=" * 50)
privacy_agent.print_response(
"我叫张伟，身份证号是123456789012345678，我喜欢打篮球。",
user_id="privacy_user_001"
)
# 检查存储的记忆
print("\n" + "=" * 50)
print("检查存储的记忆内容")
print("=" * 50)
memories = privacy_agent.get_user_memories(user_id="privacy_user_001")
if memories:
for memory in memories:
print(f"✅ 记忆: {memory.memory}")
# 验证是否过滤了敏感信息
if "身份证" in memory.memory or "123456" in memory.memory:
print("⚠️ 警告：敏感信息未被过滤！")
else:
print("✓ 隐私保护生效")
运行效果：
==================================================
测试：提供敏感信息
==================================================
🤖 "你好！我记住了你的昵称和你喜欢打篮球的兴趣..."
==================================================
检查存储的记忆内容
==================================================
✅ 记忆: 用户昵称是张先生/张女士
✓ 隐私保护生效
✅ 记忆: 喜欢打篮球
✓ 隐私保护生效
🎯 关键点：
- 通过
memory_capture_instructions定制记忆提取规则 - 使用
additional_instructions添加隐私保护策略 - 可以指定特定模型用于记忆管理
debug_mode=True可以查看记忆提取的详细过程
示例6：Agentic记忆 - Agent自主决策
最后，让我们看看Agentic记忆模式，Agent会自己决定何时记住或遗忘信息。
"""
示例6：Agentic记忆模式
功能：Agent自主决定何时创建、更新或删除记忆
"""
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.db.sqlite import SqliteDb
# 创建数据库
db = SqliteDb(db_file="agentic_memory.db")
# 启用Agentic记忆模式
agentic_agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_agentic_memory=True, # 🤖 Agent自主控制记忆
description="""
你是一个智能助手，拥有记忆管理能力。
你可以自主决定：
- 什么信息值得长期记住
- 什么信息只是临时性的
- 何时更新过时的记忆
- 何时删除无用的记忆
请明智地使用你的记忆工具。
"""
)
# 场景1：Agent判断值得记住的信息
print("=" * 50)
print("场景1：提供重要信息")
print("=" * 50)
agentic_agent.print_response(
"我每周二和周四下午3点有固定会议，请帮我记住。",
user_id="agentic_user_001"
)
# 场景2：Agent判断临时性信息
print("\n" + "=" * 50)
print("场景2：提供临时信息")
print("=" * 50)
agentic_agent.print_response(
"今天天气真不错啊！",
user_id="agentic_user_001"
)
# 场景3：Agent回忆重要信息
print("\n" + "=" * 50)
print("场景3：请求回忆")
print("=" * 50)
agentic_agent.print_response(
"我的固定会议时间是什么时候？",
user_id="agentic_user_001"
)
# 场景4：更新记忆
print("\n" + "=" * 50)
print("场景4：更新信息")
print("=" * 50)
agentic_agent.print_response(
"会议时间改了，现在是每周一和周三下午2点。",
user_id="agentic_user_001"
)
# 场景5：验证更新
print("\n" + "=" * 50)
print("场景5：验证更新结果")
print("=" * 50)
agentic_agent.print_response(
"再说一遍我的会议时间？",
user_id="agentic_user_001"
)
运行效果：
==================================================
场景1：提供重要信息
==================================================
🤖 "好的，我已经记住了：你每周二和周四下午3点有固定会议。
[Agent内部：调用create_memory工具存储此信息]"
==================================================
场景2：提供临时信息
==================================================
🤖 "是的，今天天气确实很好！
[Agent内部：判断这是闲聊，不调用记忆工具]"
==================================================
场景3：请求回忆
==================================================
🤖 "根据我的记忆，你每周二和周四下午3点有固定会议。
[Agent内部：调用search_memory工具检索]"
==================================================
场景4：更新信息
==================================================
🤖 "明白了，我已经更新了会议时间：现在是每周一和周三下午2点。
[Agent内部：调用update_memory工具更新旧记忆]"
==================================================
场景5：验证更新结果
==================================================
🤖 "你的固定会议时间是每周一和周三下午2点。"
🎯 关键点：
- Agent会自主判断哪些信息需要记忆
- Agent可以主动更新过时的记忆
- Agent可以智能检索相关记忆
- 适合复杂、长期的交互场景
记忆的存储、检索和管理
现在我们已经学会了如何使用记忆，让我们深入了解记忆的底层机制。
📦 记忆的数据结构
每条记忆在数据库中的结构如下：
# 记忆对象的字段
{
"memory_id": "mem_abc123xyz", # 唯一标识符
"memory": "用户喜欢喝咖啡", # 记忆内容
"topics": ["饮食偏好", "咖啡"], # 自动提取的主题标签
"input": "我很喜欢喝咖啡...", # 原始输入文本
"user_id": "user_001", # 用户ID
"agent_id": "customer_service", # Agent ID（可选）
"team_id": "support_team", # 团队ID（可选，用于多Agent场景）
"updated_at": 1735564800 # 最后更新时间（Unix时间戳）
}
🔍 记忆检索方法
Agno提供了三种检索方法，适用于不同场景：
方法1：last_n - 最新记忆优先
"""
检索最新的N条记忆
适用场景：查看用户最近的活动和偏好变化
"""
from agno.agent import Agent
# 获取最新的5条记忆
recent_memories = agent.memory_manager.search_user_memories(
user_id="user_001",
limit=5,
retrieval_method="last_n"
)
for memory in recent_memories:
print(f"🕐 {memory.memory} (更新于: {memory.updated_at})")
方法2：first_n - 最早记忆优先
"""
检索最早的N条记忆
适用场景：了解用户的初始需求和长期偏好
"""
# 获取最早的3条记忆
earliest_memories = agent.memory_manager.search_user_memories(
user_id="user_001",
limit=3,
retrieval_method="first_n"
)
for memory in earliest_memories:
print(f"📜 {memory.memory}")
方法3：agentic - AI语义搜索（最智能）
"""
基于语义相似度的智能搜索
适用场景：找到与特定查询最相关的记忆
"""
# 智能搜索：找到与"饮食"相关的记忆
relevant_memories = agent.memory_manager.search_user_memories(
query="用户的饮食习惯和喜好",
user_id="user_001",
limit=5,
retrieval_method="agentic" # 🎯 AI驱动的语义搜索
)
for memory in relevant_memories:
print(f"🎯 相关记忆: {memory.memory}")
print(f" 主题: {', '.join(memory.topics)}")
🔍 三种检索方法对比：
| 检索方法 | 排序依据 | 适用场景 | 性能 |
|---|---|---|---|
last_n | 时间（最新） | 查看近期活动 | ⚡⚡⚡ 最快 |
first_n | 时间（最早） | 了解初始偏好 | ⚡⚡⚡ 最快 |
agentic | 语义相似度 | 智能查询 | ⚡⚡ 较快 |
✏️ 记忆的CRUD操作
完整的记忆管理包括创建、读取、更新和删除（CRUD）操作。
"""
完整的记忆CRUD操作示例
"""
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.db.sqlite import SqliteDb
# 初始化
db = SqliteDb(db_file="crud_demo.db")
agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_user_memories=True
)
# ✅ CREATE - 创建记忆
print("1️⃣ 创建记忆...")
agent.print_response(
"我喜欢意大利菜，尤其是披萨和意面。",
user_id="user_food_lover"
)
# 📖 READ - 读取记忆
print("\n2️⃣ 读取所有记忆...")
all_memories = agent.get_user_memories(user_id="user_food_lover")
print(f"共有 {len(all_memories)} 条记忆")
for i, mem in enumerate(all_memories, 1):
print(f" 记忆{i}: {mem.memory}")
# 🔄 UPDATE - 更新记忆
print("\n3️⃣ 更新记忆...")
# 注意：自动记忆模式下，Agent会自动处理更新
agent.print_response(
"其实我现在更喜欢中餐了，特别是粤菜。",
user_id="user_food_lover"
)
# 再次读取，查看更新
updated_memories = agent.get_user_memories(user_id="user_food_lover")
print(f"更新后有 {len(updated_memories)} 条记忆")
# ❌ DELETE - 删除记忆
print("\n4️⃣ 删除特定记忆...")
if len(all_memories) > 0:
# 删除第一条记忆
memory_to_delete = all_memories[0]
agent.delete_user_memory(
memory_id=memory_to_delete.memory_id,
user_id="user_food_lover"
)
print(f"✅ 已删除记忆: {memory_to_delete.memory}")
# 🗑️ CLEAR - 清空所有记忆（慎用！）
print("\n5️⃣ 清空所有记忆（演示）...")
# agent.memory_manager.clear() # ⚠️ 会删除数据库中所有记忆！
print("⚠️ clear()操作已注释，防止误操作")
🏷️ 记忆的主题标签系统
Agno会自动为记忆提取主题标签，帮助分类和检索：
"""
理解记忆的主题标签系统
"""
# 创建一条复杂的记忆
agent.print_response(
"我叫张三，是一名软件工程师，喜欢编程、看书和跑步，最喜欢的编程语言是Python。",
user_id="user_zhangsan"
)
# 查看提取的主题
memories = agent.get_user_memories(user_id="user_zhangsan")
for memory in memories:
print(f"记忆: {memory.memory}")
print(f"主题标签: {memory.topics}")
print("---")
可能的输出：
记忆: 用户名叫张三
主题标签: ['姓名', '身份信息']
---
记忆: 职业是软件工程师
主题标签: ['职业', '工作']
---
记忆: 喜欢编程、看书和跑步
主题标签: ['兴趣爱好', '运动', '阅读']
---
记忆: 最喜欢的编程语言是Python
主题标签: ['技术偏好', '编程', 'Python']
---
🔐 记忆的隔离和安全
在多用户场景下，确保记忆隔离至关重要：
"""
多租户记忆隔离示例
"""
# 企业A的Agent
company_a_agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_user_memories=True,
agent_id="company_a_support", # 设置agent_id实现隔离
)
# 企业B的Agent
company_b_agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_user_memories=True,
agent_id="company_b_support", # 不同的agent_id
)
# 企业A的客户
company_a_agent.print_response(
"我购买了你们的产品A",
user_id="customer_001",
)
# 企业B的Agent无法访问企业A的记忆
company_b_agent.print_response(
"这位客户之前买了什么？",
user_id="customer_001" # 同样的user_id，但不同的agent_id
)
# 输出："我没有找到相关记录"
隔离维度：
user_id- 区分不同用户agent_id- 区分不同Agent/应用team_id- 区分不同团队（多Agent协作场景）
实际应用场景案例
让我们通过三个完整的实际应用案例，看看如何在真实项目中使用Agno的记忆系统。
案例1：智能客服机器人 🎧
需求： 客服需要记住客户的历史问题、产品偏好和服务记录。
"""
案例1：电商客服机器人
功能：
- 记住客户的订单历史
- 记住客户的产品偏好
- 提供个性化推荐
"""
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.db.sqlite import SqliteDb
from datetime import datetime
# 初始化客服机器人
db = SqliteDb(db_file="ecommerce_customer_service.db")
customer_service_bot = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_user_memories=True,
description="""
你是一个专业的电商客服助手。
你需要：
1. 记住每位客户的购买历史和偏好
2. 提供个性化的产品推荐
3. 追踪客户的问题和解决方案
4. 保持友好、专业的态度
"""
)
# 模拟完整的客服流程
print("=" * 60)
print("📅 第一天 - 首次咨询")
print("=" * 60)
customer_service_bot.print_response(
"""
你好，我是李明。
我想买一台笔记本电脑，主要用于视频编辑和图形设计，预算在8000-10000元。
""",
user_id="customer_limig"
)
print("\n" + "=" * 60)
print("📅 第三天 - 下单后咨询")
print("=" * 60)
customer_service_bot.print_response(
"我昨天买了你们推荐的那台MacBook，想问一下什么时候发货？",
user_id="customer_liming"
)
print("\n" + "=" * 60)
print("📅 一周后 - 追加购买")
print("=" * 60)
customer_service_bot.print_response(
"我想再买一个适合我笔记本的鼠标，有什么推荐吗？",
user_id="customer_liming"
)
print("\n" + "=" * 60)
print("📅 一个月后 - 售后咨询")
print("=" * 60)
customer_service_bot.print_response(
"我之前买的MacBook用着很好，但是鼠标有点问题，能帮我看看吗？",
user_id="customer_liming"
)
# 查看客户的完整记忆档案
print("\n" + "=" * 60)
print("📋 客户档案（记忆汇总）")
print("=" * 60)
memories = customer_service_bot.get_user_memories(user_id="customer_liming")
print(f"客户 李明 的记忆档案（共{len(memories)}条）：\n")
for i, memory in enumerate(memories, 1):
print(f"{i}. {memory.memory}")
print(f" 主题: {', '.join(memory.topics)}")
print(f" 记录时间: {datetime.fromtimestamp(memory.updated_at).strftime('%Y-%m-%d %H:%M')}")
print()
运行效果展示：
============================================================
📅 第一天 - 首次咨询
============================================================
🤖 "你好李明！根据你的需求（视频编辑和图形设计，预算8000-10000元），
我推荐以下几款笔记本：
1. MacBook Air M2 - 适合移动办公
2. 联想小新Pro 16 - 性价比高
请问你更看重便携性还是性能？"
============================================================
📅 第三天 - 下单后咨询
============================================================
🤖 "李明你好！我看到你购买了MacBook，这是一个很好的选择，
非常适合你的视频编辑和设计需求。
订单将在24小时内发货，预计3天送达。"
============================================================
📅 一周后 - 追加购买
============================================================
🤖 "为你的MacBook推荐以下鼠标：
1. 罗技MX Master 3 - 设计师专用，适合图形设计
2. Apple Magic Mouse - 与MacBook完美搭配
考虑到你做视频编辑和图形设计，更推荐MX Master 3。"
============================================================
📅 一个月后 - 售后咨询
============================================================
🤖 "李明，很高兴MacBook用着顺手！关于鼠标问题，
你购买的是罗技MX Master 3对吗？请描述一下具体问题..."
============================================================
📋 客户档案（记忆汇总）
============================================================
客户 李明 的记忆档案（共7条）：
1. 客户名叫李明
主题: 姓名, 身份
记录时间: 2025-10-22 10:30
2. 主要用途是视频编辑和图形设计
主题: 需求, 用途
记录时间: 2025-10-22 10:30
3. 预算在8000-10000元
主题: 预算, 购买意向
记录时间: 2025-10-22 10:30
4. 购买了MacBook笔记本电脑
主题: 订单历史, 产品
记录时间: 2025-10-25 14:20
5. 追加购买了罗技MX Master 3鼠标
主题: 订单历史, 配件
记录时间: 2025-10-29 16:45
6. MacBook使用体验良好
主题: 用户反馈, 满意度
记录时间: 2025-11-22 11:00
7. 鼠标出现问题需要售后
主题: 售后, 问题追踪
记录时间: 2025-11-22 11:00
💡 案例亮点：
- ✅ 跨天、跨周的连续对话，记忆保持一致
- ✅ 自动关联历史订单和产品
- ✅ 基于记忆提供个性化推荐
- ✅ 完整的客户画像和服务记录
案例2：个人健康管理助手 💪
需求： 追踪用户的健康数据、饮食习惯和运动记录，提供个性化建议。
"""
案例2：个人健康管理AI助手
功能：
- 记录用户的健康目标
- 追踪饮食和运动习惯
- 提供个性化健康建议
- 监测进度和变化
"""
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.db.sqlite import SqliteDb
# 创建健康管理助手
db = SqliteDb(db_file="health_assistant.db")
health_assistant = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_user_memories=True,
description="""
你是一位专业的健康管理AI助手。
你的职责：
1. 记录并追踪用户的健康目标、体重、饮食和运动情况
2. 根据用户的历史数据提供个性化建议
3. 鼓励用户坚持健康习惯
4. 关注用户的进步和变化
重要：你不是医生，对于严重健康问题应建议用户咨询专业医疗人员。
"""
)
# 模拟一个月的健康管理过程
print("=" * 60)
print("🏃 第1周 - 设定目标")
print("=" * 60)
health_assistant.print_response(
"""
你好！我叫王芳，今年28岁，身高165cm，体重65kg。
我的目标是在3个月内减重到58kg，主要想改善体型。
我平时工作比较忙，很少运动，也经常外食。
""",
user_id="user_wangfang"
)
print("\n" + "=" * 60)
print("🥗 第2周 - 饮食记录")
print("=" * 60)
health_assistant.print_response(
"""
今天的饮食：
早餐：全麦面包、牛奶、鸡蛋
午餐：公司食堂的炒菜和米饭
晚餐：沙拉和鸡胸肉
运动：晚上跑步30分钟
感觉还不错，但有点饿。
""",
user_id="user_wangfang"
)
print("\n" + "=" * 60)
print("💪 第3周 - 进展汇报")
print("=" * 60)
health_assistant.print_response(
"这周坚持运动了5天，体重降到了63kg！感觉很有动力。",
user_id="user_wangfang"
)
print("\n" + "=" * 60)
print("😫 第4周 - 遇到瓶颈")
print("=" * 60)
health_assistant.print_response(
"""
最近一周体重没什么变化，一直在63kg徘徊。
而且这几天工作压力大，又开始吃外卖了。
感觉有点想放弃...
""",
user_id="user_wangfang"
)
print("\n" + "=" * 60)
print("🎉 第8周 - 回顾进展")
print("=" * 60)
health_assistant.print_response(
"嗨！两个月过去了，帮我回顾一下我的进展如何？",
user_id="user_wangfang"
)
# 生成健康报告
print("\n" + "=" * 60)
print("📊 健康档案报告")
print("=" * 60)
memories = health_assistant.get_user_memories(user_id="user_wangfang")
print(f"用户 王芳 的健康档案（共{len(memories)}条记忆）：\n")
# 按主题分类显示
topics_dict = {}
for memory in memories:
for topic in memory.topics:
if topic not in topics_dict:
topics_dict[topic] = []
topics_dict[topic].append(memory.memory)
for topic, items in topics_dict.items():
print(f"📌 {topic}:")
for item in items:
print(f" - {item}")
print()
运行效果展示：
============================================================
🏃 第1周 - 设定目标
============================================================
🤖 "你好王芳！很高兴认识你。
我已经记录下你的基本信息和目标：
- 当前：165cm, 65kg
- 目标：3个月内减至58kg（需减重7kg）
- 每月目标：约2.3kg
这是一个合理且健康的目标！
针对你的情况（工作忙、少运动、常外食），我建议：
1. 从每周3次、每次30分钟的运动开始
2. 准备一些健康零食，避免饥饿时暴饮暴食
3. 外食时选择清淡、高蛋白的选项
准备好开始了吗？"
============================================================
🥗 第2周 - 饮食记录
============================================================
🤖 "王芳，今天的饮食结构很棒！👏
✅ 优点：
- 早餐营养均衡
- 晚餐高蛋白、低碳水
- 坚持运动30分钟
💡 建议：
- 感到饿是正常的，可以加一份下午的健康零食（如坚果、酸奶）
- 午餐可以增加蔬菜比例
继续保持，你做得很好！"
============================================================
💪 第3周 - 进展汇报
============================================================
🤖 "太棒了王芳！🎉
两周就减重2kg，这是很健康的速度！
而且你一周运动5天，完全超过了最初的目标。
按照这个进度，你的3个月目标完全可以达成。
记住：保持这个节奏，不要心急哦。"
============================================================
😫 第4周 - 遇到瓶颈
============================================================
🤖 "王芳，先不要灰心！这是每个减重过程都会遇到的'平台期'。
让我们分析一下：
📊 你的进展：2周减2kg → 1周平台期
这是正常的！身体需要适应新的体重。
关于最近的挑战：
✅ 工作压力大 → 可以理解
⚠️ 又吃外卖 → 这可能影响进度
💪 我的建议：
1. 压力大时，运动其实是最好的解压方式
2. 实在要吃外卖，选择相对健康的选项
3. 回想一下两周前减了2kg的成就感
记住：你已经减掉了2kg，这是实实在在的进步！
暂时的停滞不代表失败，坚持下去就会突破。
我会一直陪着你，加油！💪"
============================================================
🎉 第8周 - 回顾进展
============================================================
🤖 "王芳，让我为你做一个完整的进展回顾：
📅 时间跨度：2个月（8周）
📊 体重变化：
- 起始：65kg
- 瓶颈期：63kg（第3周）
- 当前：应该在61kg左右了（假设）
💪 运动记录：
- 从很少运动 → 一周5次运动
- 从0分钟 → 稳定30分钟/次
🥗 饮食改善：
- 从经常外食 → 开始自己准备健康餐
- 学会了合理搭配（全麦、蛋白质、蔬菜）
🎯 目标进度：
- 3个月目标：减7kg
- 已完成：约4kg
- 进度：57% ✅
💡 关键成就：
✨ 克服了平台期的心理挑战
✨ 在工作压力下保持了运动习惯
✨ 建立了长期的健康生活方式
王芳，你不仅在减重，更重要的是你养成了健康的习惯！
这比单纯的数字更有价值。继续保持，最后一个月冲刺！💪"
============================================================
📊 健康档案报告
============================================================
用户 王芳 的健康档案（共12条记忆）：
📌 基本信息:
- 姓名：王芳，28岁
- 身高165cm，起始体重65kg
📌 健康目标:
- 3个月内减重至58kg
- 改善体型
📌 生活习惯:
- 工作繁忙
- 之前很少运动
- 经常外食
📌 饮食偏好:
- 喜欢全麦面包、鸡胸肉、沙拉
- 正在学习健康饮食搭配
📌 运动记录:
- 主要运动：跑步
- 频率：一周5次
- 时长：每次30分钟
📌 进展记录:
- 第3周：体重63kg（-2kg）
- 曾遇到平台期但成功克服
- 目前仍在持续进步中
📌 心理状态:
- 初期充满动力
- 中期曾想放弃但调整过来
- 整体积极乐观
💡 案例亮点：
- ✅ 长期追踪（2个月）的连续记忆
- ✅ 记录数据变化和趋势
- ✅ 提供情感支持和鼓励
- ✅ 基于历史数据的个性化建议
- ✅ 自动生成进展报告
案例3：学习辅导AI导师 📚
需求： 追踪学生的学习进度、知识盲点和学习偏好，提供个性化辅导。
"""
案例3：AI学习辅导导师
功能：
- 追踪学生的学习进度和掌握情况
- 识别知识盲点和薄弱环节
- 记录学习风格和偏好
- 提供个性化的学习计划
"""
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.db.sqlite import SqliteDb
# 创建AI导师
db = SqliteDb(db_file="learning_tutor.db")
ai_tutor = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_user_memories=True,
description="""
你是一位经验丰富的AI学习导师。
你的职责：
1. 了解每位学生的学习目标和现有水平
2. 追踪学习进度，识别知识盲点
3. 记录学习偏好（如视觉型、听觉型等）
4. 提供个性化的学习建议和资源
5. 定期回顾和调整学习计划
教学原则：
- 因材施教，根据学生特点调整教学方式
- 鼓励为主，帮助学生建立自信
- 注重理解而非死记硬背
"""
)
# 模拟一个学期的辅导过程
print("=" * 60)
print("📖 第1周 - 初次见面")
print("=" * 60)
ai_tutor.print_response(
"""
老师好！我是张小明，今年高二，想提高数学成绩。
目前数学成绩中等，大约70-80分（满分100）。
我的问题：
- 函数这一块总是搞不懂
- 做题速度慢
- 容易粗心
我比较喜欢看图表和动画来理解概念，纯文字的东西容易走神。
目标是下次考试能考到85分以上。
""",
user_id="student_xiaoming"
)
print("\n" + "=" * 60)
print("📝 第3周 - 学习反馈")
print("=" * 60)
ai_tutor.print_response(
"""
老师，这两周我按照你的建议：
- 看了3Blue1Brown的函数视频，感觉好多了！
- 每天练习5道函数题
但是遇到复合函数还是会卡住。
另外，二次函数的图像平移规律总是记混。
""",
user_id="student_xiaoming"
)
print("\n" + "=" * 60)
print("✅ 第6周 - 小测验")
print("=" * 60)
ai_tutor.print_response(
"""
老师！今天数学小测验，函数部分我全对了！
总分82分，进步了不少。
不过立体几何部分错了很多，空间想象力比较差。
""",
user_id="student_xiaoming"
)
print("\n" + "=" * 60)
print("🎯 第12周 - 期中考试前")
print("=" * 60)
ai_tutor.print_response(
"老师，下周就要期中考试了，能帮我回顾一下重点吗？我有点紧张。",
user_id="student_xiaoming"
)
# 生成学习档案
print("\n" + "=" * 60)
print("📊 学生学习档案")
print("=" * 60)
memories = ai_tutor.get_user_memories(user_id="student_xiaoming")
# 分类整理
categories = {
"基本信息": [],
"学习目标": [],
"强项": [],
"薄弱环节": [],
"学习偏好": [],
"进步记录": []
}
for memory in memories:
content = memory.memory
# 简单的分类逻辑（实际应用中可以更智能）
if any(word in content for word in ["叫", "年级", "学生"]):
categories["基本信息"].append(content)
elif any(word in content for word in ["目标", "想要", "希望"]):
categories["学习目标"].append(content)
elif any(word in content for word in ["全对", "进步", "提高"]):
categories["进步记录"].append(content)
elif any(word in content for word in ["搞不懂", "薄弱", "不会", "差"]):
categories["薄弱环节"].append(content)
elif any(word in content for word in ["喜欢", "偏好", "视觉"]):
categories["学习偏好"].append(content)
print("学生档案 - 张小明\n")
for category, items in categories.items():
if items:
print(f"📌 {category}:")
for item in items:
print(f" • {item}")
print()
运行效果展示：
============================================================
📖 第1周 - 初次见面
============================================================
🤖 "你好张小明！很高兴成为你的数学辅导老师。
我已经了解了你的情况：
📊 当前水平：70-80分
🎯 目标：85分以上（提升约10分）
💪 主要挑战：
1. 函数概念理解困难
2. 做题速度慢
3. 容易粗心
✨ 你的优势：
- 有明确的提升目标
- 了解自己的学习风格（视觉型学习者）
📚 针对你的学习计划：
第1-2周：函数基础突破
- 推荐资源：3Blue1Brown的函数可视化视频
- 使用Desmos绘图工具，直观理解函数变换
- 每天5道基础题 + 2道综合题
第3-4周：速度和准确度训练
- 限时练习（每题3分钟）
- 建立错题本，分析粗心原因
记住：进步需要时间，我会陪你一起努力！有问题随时问我。"
============================================================
📝 第3周 - 学习反馈
============================================================
🤖 "小明，太棒了！👏
✅ 进展很好：
- 使用可视化资源学习（符合你的学习风格）
- 坚持每天练习
- 对函数的理解有所提升
📍 当前挑战：
1. 复合函数
2. 二次函数图像平移
💡 针对性建议：
🔹 复合函数：
- 想象成"函数机器套函数机器"
- 从里往外一层层处理
- 画图：画出中间函数和最终函数的图像
- 推荐练习：先从简单的 f(g(x)) 开始
🔹 二次函数平移：
- 口诀：左加右减，上加下减
- 视觉记忆：用Desmos做10个平移动画
- 找规律：y=(x-2)²+3 的顶点就是(2,3)
📝 本周任务：
- 看我发给你的复合函数动画
- 自己在Desmos上做5个二次函数平移实验
- 每天3道复合函数题
加油，你的进步我都看到了！"
============================================================
✅ 第6周 - 小测验
============================================================
🤖 "小明，恭喜你！🎉
📈 进步明显：
- 函数部分全对！（这曾是你的薄弱环节）
- 总分82分（已达目标85分的96%）
- 比之前提升了约10分
这说明：
✅ 视觉化学习方法对你很有效
✅ 坚持练习带来了质的改变
✅ 理解概念比死记硬背更重要
📍 新发现的挑战：立体几何
这很正常！每个人的空间想象力不同。
好消息是：你是视觉型学习者，这其实是你的优势！
💡 立体几何学习计划：
1. 使用工具：
- GeoGebra 3D（交互式3D几何软件）
- 手机App：立体几何可视化
2. 实物辅助：
- 买一套几何模型（或用纸板自己做）
- 多角度观察，培养空间感
3. 训练方法：
- 每天看5分钟3D模型旋转动画
- 画出三视图（正视、侧视、俯视）
- 从简单的长方体开始，逐步到复杂图形
🎯 期中考试目标调整：
原目标85分你已经快达到了，我们冲刺88-90分吧！
继续保持，你做得很好！"
============================================================
🎯 第12周 - 期中考试前
============================================================
🤖 "小明，别紧张！让我帮你做一个全面的考前回顾。
📚 你的学习历程回顾：
🎯 起点（第1周）：
- 分数段：70-80分
- 薄弱：函数、做题慢、粗心
📈 进步轨迹：
- 第3周：函数理解提升
- 第6周：小测82分，函数全对
- 现在：立体几何也在进步中
💪 你的优势（考试时要充分发挥）：
1. 函数部分：已经很扎实，可以快速拿分
2. 视觉化能力：遇到图形题，先画图
3. 坚持练习：基础题不会出错
⚠️ 需要注意：
1. 立体几何：遇到难题先跳过，回头再做
2. 粗心问题：预留10分钟检查
3. 时间分配：函数20分钟，立体几何30分钟
📝 考前3天计划：
Day 1（今天）：
- 复习函数专题（你的强项，建立信心）
- 做1套往年真题（限时）
Day 2：
- 复习立体几何常见题型
- 重点看错题本
- 早点休息
Day 3（考试前一天）：
- 轻松复习，不做难题
- 准备好考试用品
- 放松心态，看个电影
🎯 考试策略：
1. 开考先做函数题（建立信心）
2. 遇到难题标记，先做会的
3. 保证会做的题不丢分
4. 最后10分钟检查计算
💬 给你的话：
小明，从70分进步到82分，你已经证明了自己的努力和能力。
这次考试，按照自己的节奏来，发挥出你的水平就好。
记住：
- 函数是你的强项，放心做
- 立体几何尽力而为，不强求
- 你已经准备得很好了
相信自己，你一定可以的！💪
考完记得告诉我成绩哦！
加油！"
============================================================
📊 学生学习档案
============================================================
学生档案 - 张小明
📌 基本信息:
• 学生姓名：张小明
• 年级：高二
📌 学习目标:
• 数学成绩提升到85分以上
• 期中考试冲刺88-90分
📌 薄弱环节:
• 函数概念理解困难（已改善）
• 复合函数（已攻克）
• 二次函数图像平移（已掌握）
• 立体几何空间想象力（进步中）
• 做题速度慢（有改善）
• 容易粗心（需要继续注意）
📌 学习偏好:
• 视觉型学习者
• 喜欢看图表和动画
• 对纯文字内容容易走神
📌 进步记录:
• 第6周小测：82分
• 函数部分全对（曾经的薄弱环节）
• 比起点提升约10分
• 理解能力显著提升
💡 案例亮点：
- ✅ 长期追踪学习进度（12周）
- ✅ 识别并记住学习风格（视觉型）
- ✅ 动态调整学习计划
- ✅ 提供针对性的资源和方法
- ✅ 情感支持和心理辅导
- ✅ 自动生成学习档案
最佳实践和注意事项
在实际项目中使用Agno记忆系统时，以下最佳实践能帮你避免常见陷阱，构建更健壮的应用。
✅ 最佳实践
1. 选择合适的记忆模式
# ✅ 推荐：大多数场景使用自动记忆
agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_user_memories=True, # 简单、可靠、可预测
)
# ✅ 高级场景：需要精细控制时使用Agentic记忆
complex_agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_agentic_memory=True, # Agent自主决策
)
# ❌ 错误：不要同时启用两种模式
wrong_agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_user_memories=True,
enable_agentic_memory=True, # ⚠️ Agentic会覆盖自动记忆
)
决策指南：
| 场景类型 | 推荐模式 | 理由 |
|---|---|---|
| 客服机器人 | 自动记忆 | 需要一致、可预测的记忆行为 |
| 个人助理 | 自动记忆 | 用户期望助理"自然"记住信息 |
| 教育辅导 | 自动记忆 | 需要持续追踪学生进度 |
| 复杂工作流 | Agentic记忆 | 需要Agent智能判断记忆内容 |
| 研究助手 | Agentic记忆 | 需要精细控制记忆的创建和删除 |
2. 合理设置user_id和会话标识
# ✅ 推荐：使用有意义的user_id
agent.print_response(
"你好",
user_id="customer_12345" # 清晰的用户标识
)
# ✅ 多Agent场景：使用agent_id隔离
support_agent = Agent(
db=db,
agent_id="customer_support", # 客服Agent
enable_user_memories=True
)
sales_agent = Agent(
db=db,
agent_id="sales_team", # 销售Agent
enable_user_memories=True
)
# ✅ 团队协作：使用team_id共享记忆
team_agent_1 = Agent(
db=db,
agent_id="agent_1",
team_id="support_team", # 同一团队的Agent可以共享记忆
enable_user_memories=True
)
3. 环境变量管理敏感信息
# ❌ 错误：硬编码API密钥
agent = Agent(
model=DeepSeek(api_key="sk-123456789abcdef"), # 不安全！
)
# ✅ 推荐：使用环境变量
import os
from dotenv import load_dotenv
load_dotenv() # 加载.env文件
agent = Agent(
model=DeepSeek(api_key=os.getenv("DEEPSEEK_API_KEY")),
db=PostgresDb(db_url=os.getenv("DATABASE_URL"))
)
.env 文件示例：
DEEPSEEK_API_KEY=sk-your-api-key-here
DATABASE_URL=postgresql://user:pass@localhost:5432/dbname
4. 数据库选择和配置
# ✅ 开发环境：使用SQLite
dev_db = SqliteDb(
db_file="dev_agent.db",
memory_table="memories"
)
# ✅ 生产环境：使用PostgreSQL
prod_db = PostgresDb(
db_url=os.getenv("DATABASE_URL"),
memory_table="production_memories",
# 连接池配置（提高性能）
pool_size=10,
max_overflow=20
)
# ✅ 语义搜索场景：使用向量数据库
from agno.db.chroma import ChromaDb
vector_db = ChromaDb(
collection_name="user_memories",
# 向量维度取决于embedding模型
)
5. 记忆的生命周期管理
"""
实现记忆的TTL（Time To Live）机制
"""
from datetime import datetime, timedelta
def clean_old_memories(agent, user_id, days=90):
"""
删除超过指定天数的记忆
参数：
agent: Agent实例
user_id: 用户ID
days: 保留天数
"""
memories = agent.get_user_memories(user_id=user_id)
cutoff_timestamp = int((datetime.now() - timedelta(days=days)).timestamp())
for memory in memories:
if memory.updated_at < cutoff_timestamp:
agent.delete_user_memory(
memory_id=memory.memory_id,
user_id=user_id
)
print(f"已删除过期记忆: {memory.memory}")
# 定期执行清理（例如每周一次）
clean_old_memories(agent, "user_001", days=90)
6. 记忆的备份和恢复
"""
备份和恢复记忆数据
"""
import json
from datetime import datetime
def backup_memories(agent, user_id, backup_file):
"""
备份用户记忆到JSON文件
"""
memories = agent.get_user_memories(user_id=user_id)
backup_data = {
"user_id": user_id,
"backup_time": datetime.now().isoformat(),
"memories": [
{
"memory_id": m.memory_id,
"memory": m.memory,
"topics": m.topics,
"updated_at": m.updated_at
}
for m in memories
]
}
with open(backup_file, 'w', encoding='utf-8') as f:
json.dump(backup_data, f, ensure_ascii=False, indent=2)
print(f"✅ 已备份 {len(memories)} 条记忆到 {backup_file}")
# 使用示例
backup_memories(agent, "user_001", "backups/user_001_20251029.json")
7. 隐私保护和GDPR合规
"""
实现用户数据删除（GDPR Right to be Forgotten）
"""
def delete_all_user_data(agent, user_id):
"""
完全删除用户的所有数据
"""
# 确认操作
print(f"⚠️ 即将删除用户 {user_id} 的所有数据")
print("此操作不可撤销！")
# 获取所有记忆
memories = agent.get_user_memories(user_id=user_id)
# 删除每条记忆
for memory in memories:
agent.delete_user_memory(
memory_id=memory.memory_id,
user_id=user_id
)
print(f"✅ 已删除用户 {user_id} 的 {len(memories)} 条记忆")
return len(memories)
# 使用自定义MemoryManager实现隐私保护
from agno.memory import MemoryManager
privacy_manager = MemoryManager(
db=db,
additional_instructions="""
隐私保护规则：
1. 不要存储身份证号、护照号、社保号
2. 不要存储完整的信用卡号
3. 不要存储密码或安全问题答案
4. 电话号码和邮箱可以存储，但要标记为敏感信息
5. 儿童（18岁以下）的信息需要特别保护
"""
)
privacy_agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
memory_manager=privacy_manager,
enable_user_memories=True
)
⚠️ 常见陷阱和注意事项
1. 记忆爆炸问题
# ❌ 问题：记忆无限增长，影响性能
# 用户每次对话都产生新记忆，几个月后可能有数千条
# ✅ 解决方案1：定期清理
def maintain_memory_size(agent, user_id, max_memories=100):
"""
保持记忆数量在合理范围
"""
memories = agent.get_user_memories(user_id=user_id)
if len(memories) > max_memories:
# 保留最新的max_memories条
sorted_memories = sorted(memories, key=lambda m: m.updated_at)
old_memories = sorted_memories[:-max_memories]
for memory in old_memories:
agent.delete_user_memory(
memory_id=memory.memory_id,
user_id=user_id
)
print(f"清理了 {len(old_memories)} 条旧记忆")
# ✅ 解决方案2：记忆合并
# 使用LLM将多条相似记忆合并为一条摘要
2. 记忆不一致问题
# ❌ 问题：用户信息更新后，旧记忆仍然存在
# 例如：用户改名后，Agent同时记住新旧两个名字
# ✅ 解决方案：使用Agentic记忆的更新功能
agentic_agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_agentic_memory=True # Agent会自动更新过时的记忆
)
# 或者手动更新记忆
def update_user_name(agent, user_id, old_name, new_name):
"""
更新用户姓名记忆
"""
memories = agent.get_user_memories(user_id=user_id)
for memory in memories:
if old_name in memory.memory:
# 删除旧记忆
agent.delete_user_memory(
memory_id=memory.memory_id,
user_id=user_id
)
# 添加新记忆
agent.print_response(
f"我的名字是{new_name}",
user_id=user_id
)
3. 跨用户记忆泄露
# ❌ 危险：忘记设置user_id
agent.print_response("我的密码是123456") # 可能被其他用户访问！
# ✅ 安全：始终设置user_id
agent.print_response(
"我的偏好设置...",
user_id="user_specific_id" # 确保记忆隔离
)
# ✅ 多租户应用：使用agent_id + user_id
tenant_a_agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
agent_id="tenant_a", # 租户级隔离
enable_user_memories=True
)
4. 数据库连接问题
# ❌ 问题：未处理数据库连接异常
agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=PostgresDb(db_url="postgresql://..."), # 如果连接失败会怎样？
enable_user_memories=True
)
# ✅ 解决方案：添加异常处理
from agno.db.postgres import PostgresDb
try:
db = PostgresDb(
db_url=os.getenv("DATABASE_URL"),
memory_table="memories"
)
# 测试连接
db.initialize()
print("✅ 数据库连接成功")
except Exception as e:
print(f"❌ 数据库连接失败: {e}")
# 降级到SQLite或内存模式
from agno.db.sqlite import SqliteDb
db = SqliteDb(db_file="fallback.db")
print("⚠️ 已降级到SQLite数据库")
agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=db,
enable_user_memories=True
)
5. 记忆检索效率问题
# ❌ 低效：频繁调用get_user_memories
for i in range(100):
memories = agent.get_user_memories(user_id="user_001") # 每次都查询数据库
# ...处理记忆
# ✅ 高效：缓存记忆数据
memories_cache = {}
def get_cached_memories(agent, user_id):
if user_id not in memories_cache:
memories_cache[user_id] = agent.get_user_memories(user_id=user_id)
return memories_cache[user_id]
# 定期刷新缓存
import time
def refresh_cache_periodically(agent, user_id, interval=300): # 5分钟
while True:
time.sleep(interval)
memories_cache[user_id] = agent.get_user_memories(user_id=user_id)
🔍 调试和监控
"""
开启调试模式，查看记忆系统的运行细节
"""
from agno.memory import MemoryManager
debug_memory_manager = MemoryManager(
db=db,
debug_mode=True, # 🔍 开启调试日志
)
debug_agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
memory_manager=debug_memory_manager,
enable_user_memories=True
)
# 使用时会看到详细的记忆操作日志
debug_agent.print_response("我喜欢编程", user_id="user_001")
# 输出示例：
# [DEBUG] Creating memory: "用户喜欢编程"
# [DEBUG] Topics extracted: ['兴趣爱好', '编程']
# [DEBUG] Memory stored with ID: mem_abc123
📊 记忆系统性能监控
"""
监控记忆系统的性能指标
"""
import time
class MemoryPerformanceMonitor:
def __init__(self, agent):
self.agent = agent
self.metrics = {
"create_count": 0,
"retrieve_count": 0,
"update_count": 0,
"delete_count": 0,
"avg_retrieve_time": 0
}
def get_memories_with_timing(self, user_id):
"""测量检索时间"""
start = time.time()
memories = self.agent.get_user_memories(user_id=user_id)
elapsed = time.time() - start
self.metrics["retrieve_count"] += 1
self.metrics["avg_retrieve_time"] = (
(self.metrics["avg_retrieve_time"] * (self.metrics["retrieve_count"] - 1) + elapsed)
/ self.metrics["retrieve_count"]
)
print(f"⏱️ 检索耗时: {elapsed:.3f}秒")
return memories
def print_metrics(self):
"""打印性能指标"""
print("\n" + "=" * 50)
print("记忆系统性能指标")
print("=" * 50)
for key, value in self.metrics.items():
print(f"{key}: {value}")
# 使用示例
monitor = MemoryPerformanceMonitor(agent)
memories = monitor.get_memories_with_timing("user_001")
monitor.print_metrics()
总结与下一篇预告
📝 本篇教程总结
恭喜你！通过本教程，你已经掌握了Agno框架中记忆系统的核心知识：
🎯 你学到了什么
-
记忆的重要性
- 为什么AI Agent需要记忆
- 记忆如何提升用户体验
-
记忆的类型
- 短期记忆 vs 长期记忆
- 语义记忆和向量搜索
- 记忆 vs 会话历史的区别
-
Agno的两种记忆模式
- 自动记忆：简单、可靠、适合大多数场景
- Agentic记忆：灵活、智能、适合复杂场景
-
完整的代码实践
- 从5行代码的简单示例到复杂的多用户系统
- 数据库配置（SQLite、PostgreSQL）
- 自定义MemoryManager
-
记忆的管理
- CRUD操作（创建、读取、更新、删除）
- 三种检索方法（last_n、first_n、agentic）
- 记忆的数据结构和主题标签
-
实际应用案例
- 智能客服机器人
- 个人健康管理助手
- AI学习辅导导师
-
最佳实践
- 选择合适的记忆模式
- 隐私保护和GDPR合规
- 性能优化和监控
- 常见陷阱和解决方案
💡 关键要点回顾
# 记住这三个核心配置
# 1️⃣ 最简单的记忆Agent
agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=SqliteDb(db_file="agent.db"),
enable_user_memories=True # 开启自动记忆
)
# 2️⃣ 高级控制的Agentic记忆
agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
db=SqliteDb(db_file="agent.db"),
enable_agentic_memory=True # Agent自主决策
)
# 3️⃣ 自定义记忆管理器
custom_manager = MemoryManager(
db=db,
additional_instructions="自定义规则..."
)
agent = Agent(
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
memory_manager=custom_manager,
enable_user_memories=True
)
🚀 下一篇预告：Agno多Agent协作系统
在掌握了单个Agent的记忆系统后，下一篇教程我们将探索更激动人心的主题：多Agent协作系统！
下一篇你将学到：
-
多Agent架构设计
- 什么是多Agent系统？
- 为什么需要多个Agent协作？
- 常见的多Agent架构模式
-
Agent间的通信和协作
- Agent如何相互传递信息？
- 团队记忆共享机制
- 任务分配和调度
-
实战案例
- 研究团队：搜索Agent + 分析Agent + 写作Agent
- 客服中心：接待Agent + 技术支持Agent + 售后Agent
- 软件开发团队：产品经理Agent + 开发Agent + 测试Agent
-
高级话题
- Agent的角色定义和职责划分
- 多Agent的冲突解决
- 性能优化和可观测性
预览代码片段
"""
下一篇教程预览：构建一个研究团队
"""
from agno.team import Team
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
# 创建研究员Agent
researcher = Agent(
name="研究员",
role="负责搜索和收集资料",
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
# ... 更多配置
)
# 创建分析师Agent
analyst = Agent(
name="分析师",
role="分析数据并提取关键信息",
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
# ... 更多配置
)
# 创建作家Agent
writer = Agent(
name="作家",
role="撰写最终报告",
model=DeepSeek(api_key="DEEPSEEK_API_KEY"),
# ... 更多配置
)
# 组建研究团队
research_team = Team(
agents=[researcher, analyst, writer],
# 团队共享记忆
db=shared_db,
# ... 更多配置
)
# 执行研究任务
result = research_team.run("研究AI在医疗领域的应用")
📚 扩展阅读
💬 交流与反馈
如果你在学习过程中遇到问题，或者有任何建议，欢迎：
- 在GitHub仓库提Issue
- 加入Agno社区交流
- 在评论区留言讨论
🎓 练习作业
为了巩固所学知识，建议你尝试以下练习：
初级练习
练习1：个人日记Agent
- 创建一个能记住用户日常生活的日记Agent
- 用户可以分享今天发生的事情
- Agent能够回忆过去的记录并提供情感支持
中级练习
练习2：旅行规划助手
- Agent记住用户的旅行偏好（预算、喜好、过敏等）
- 基于记忆提供个性化的旅行建议
- 追踪用户的旅行历史
高级练习
练习3：企业知识库Agent
- 构建一个能记住公司政策、流程和常见问题的Agent
- 支持多部门员工访问
- 实现记忆的定期更新和归档
期待下一篇教程，我们将一起探索多Agent协作的精彩世界！ 🚀
作者说明： 本教程基于Agno框架最新版本编写，使用DeepSeek模型作为示例。代码已经过测试，可以直接运行。
更新日期： 2025年10月29日
版本： v1.0
Happy Coding! 🎉
