MiniCPM-o-4.5-nvidia-FlagOS入门指南：Gradio state组件实现跨会话用户偏好记忆

1. 引言

你有没有遇到过这样的情况？每次打开一个AI对话应用，都要重新告诉它你的名字、你喜欢的对话风格，或者你希望它用哪种语言回复。就像每次去一家常去的咖啡馆，服务员都记不住你爱喝美式不加糖一样，体验总差那么一点。

今天，我们就来解决这个问题。我将带你一步步为MiniCPM-o-4.5-nvidia-FlagOS这个强大的多模态AI助手，加上一个“记忆”功能。通过Gradio的state组件，让AI记住你的偏好，实现跨会话的个性化体验。

这篇文章适合所有对AI应用开发感兴趣的朋友，无论你是刚接触Gradio的新手，还是想为现有项目添加新功能的开发者。我会用最直白的方式，从零开始讲解，确保你能跟着做出来。

2. 项目概览与环境准备

2.1 什么是MiniCPM-o-4.5-nvidia-FlagOS？

简单来说，这是一个能看能说的AI助手。你给它一张图片，它能描述图片内容；你问它问题，它能用文字回答。它基于MiniCPM-o-4.5模型，通过FlagOS软件栈在NVIDIA GPU上高效运行。

FlagOS是个好东西，它让不同的芯片都能高效运行大模型。就像给不同品牌的汽车装上了通用的导航系统，不管什么硬件，都能跑得又快又稳。

2.2 你需要准备什么？

在开始之前，确保你的电脑或服务器满足以下条件：

• 一块NVIDIA显卡：RTX 4090 D或者兼容CUDA的其他型号都行
• CUDA 12.8或更高版本：这是让显卡跑AI的“驱动程序”
• Python 3.10：编程语言环境
• 大约18GB的存储空间：用来存放模型文件

如果你已经按照之前的指南部署好了MiniCPM-o-4.5-nvidia-FlagOS，那么基础环境就已经准备好了。如果还没部署，可以先用下面的命令快速启动：

python3 /root/MiniCPM-o-4.5-nvidia-FlagOS/app.py

启动后，在浏览器打开 http://localhost:7860，就能看到AI助手的界面了。

3. 理解Gradio的state组件

3.1 state是什么？为什么需要它？

想象一下state就像AI助手的“小本本”。每次你和AI对话，它都会在这个小本本上记下一些关键信息：你叫什么名字、你喜欢什么风格、上次聊到了哪里等等。

没有state的时候，每次刷新页面或者重新打开应用，这个小本本就清零了。AI就像得了健忘症，完全不记得你是谁。有了state，AI就能记住这些信息，下次见面时还能接着聊。

3.2 state能存什么？

state组件可以存储各种类型的数据：

• 字符串：比如你的名字、偏好语言
• 数字：比如对话次数、字体大小设置
• 列表：比如历史对话记录
• 字典：比如复杂的用户配置
• 自定义对象：比如整个对话状态

在我们的场景里，我们主要用它来存储用户的个性化偏好，让AI能提供更贴心的服务。

4. 实现跨会话用户偏好记忆

4.1 分析现有代码结构

我们先来看看原来的app.py大概是什么样子（简化版）：

import gradio as gr
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# 加载模型和分词器
model_path = "/root/ai-models/FlagRelease/MiniCPM-o-4___5-nvidia-FlagOS"
model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.bfloat16)
tokenizer = AutoTokenizer.from_pretrained(model_path)

def chat_with_ai(message, history, image=None):
    """处理用户输入并生成回复"""
    # 这里原本是处理对话的逻辑
    # 但没有任何记忆功能
    response = "这是AI的回复"
    return response

# 创建Gradio界面
with gr.Blocks() as demo:
    gr.Markdown("# MiniCPM-o-4.5 AI助手")
    
    with gr.Row():
        with gr.Column():
            image_input = gr.Image(label="上传图片", type="pil")
            text_input = gr.Textbox(label="输入问题", placeholder="问我任何问题...")
            submit_btn = gr.Button("发送")
        
        with gr.Column():
            chat_output = gr.Chatbot(label="对话记录")
    
    submit_btn.click(
        fn=chat_with_ai,
        inputs=[text_input, chat_output, image_input],
        outputs=chat_output
    )

demo.launch(server_name="0.0.0.0", server_port=7860)

这个版本功能完整，但缺少记忆能力。每次对话都是全新的开始。

4.2 设计用户偏好数据结构

我们要让AI记住什么？我建议从这几个简单的偏好开始：

1. 用户名称：AI可以个性化称呼你
2. 对话风格：正式、友好、幽默等
3. 回复语言：中文、英文或其他
4. 字体大小：方便阅读的字体设置
5. 历史对话摘要：记住重要的对话内容

我们可以用一个Python字典来存储这些信息：

default_preferences = {
    "user_name": "访客",  # 默认用户名
    "conversation_style": "友好",  # 对话风格
    "language": "中文",  # 回复语言
    "font_size": "中等",  # 字体大小
    "conversation_history": [],  # 历史对话
    "important_topics": []  # 重要话题记录
}

4.3 改造聊天函数，加入记忆功能

现在我们来修改chat_with_ai函数，让它能读取和更新用户偏好：

def chat_with_ai(message, history, image=None, state=None):
    """
    增强版的聊天函数，支持用户偏好记忆
    
    参数:
        message: 用户输入的消息
        history: 当前对话历史
        image: 用户上传的图片（可选）
        state: 存储用户偏好的state对象
    """
    
    # 如果没有state，初始化一个
    if state is None:
        state = default_preferences.copy()
    
    # 从state中读取用户偏好
    user_name = state.get("user_name", "访客")
    conversation_style = state.get("conversation_style", "友好")
    language = state.get("language", "中文")
    
    # 个性化问候（如果是新对话）
    if not history:  # 历史为空，说明是新对话
        greeting = f"你好{user_name}！"
        if conversation_style == "正式":
            greeting = f"尊敬的{user_name}，您好。"
        elif conversation_style == "幽默":
            greeting = f"嘿{user_name}！今天过得怎么样？"
        
        # 根据语言偏好调整
        if language == "英文":
            greeting = f"Hello {user_name}!"
        
        history.append((None, greeting))
    
    # 处理用户消息（这里简化了，实际需要调用模型）
    # 在实际应用中，这里会调用MiniCPM模型生成回复
    ai_response = generate_response(message, image, state)
    
    # 更新对话历史
    history.append((message, ai_response))
    
    # 更新state中的历史记录（只保留最近10条）
    state["conversation_history"] = history[-10:]  # 只保留最近10条
    
    # 检查是否需要更新用户信息
    update_user_preferences(message, state)
    
    return history, state

def generate_response(message, image, state):
    """调用MiniCPM模型生成回复（简化版）"""
    # 这里应该是实际调用模型的代码
    # 为了示例，我们返回一个模拟回复
    
    user_name = state.get("user_name", "访客")
    style = state.get("conversation_style", "友好")
    
    if "我叫" in message or "我的名字是" in message:
        # 提取名字的逻辑（实际应该更复杂）
        if "我叫" in message:
            name = message.split("我叫")[1].strip()
        else:
            name = message.split("我的名字是")[1].strip()
        
        state["user_name"] = name
        return f"好的，我记住你的名字是{name}了！"
    
    # 根据风格生成不同回复
    if style == "正式":
        return f"{user_name}，根据您的问题，我的分析如下：..."
    elif style == "幽默":
        return f"哈哈，{user_name}这个问题问得好！让我想想..."
    else:  # 友好风格
        return f"{user_name}，关于这个问题，我的想法是..."

4.4 创建带state的Gradio界面

现在我们来创建完整的界面，加入state组件：

import gradio as gr
import json
from datetime import datetime

# 初始化默认偏好
default_preferences = {
    "user_name": "访客",
    "conversation_style": "友好",
    "language": "中文",
    "font_size": "中等",
    "theme": "默认",
    "conversation_history": [],
    "important_topics": [],
    "last_updated": datetime.now().isoformat()
}

def save_preferences_to_file(state):
    """将用户偏好保存到文件（实现持久化存储）"""
    try:
        with open("user_preferences.json", "w", encoding="utf-8") as f:
            # 转换datetime对象为字符串
            state_to_save = state.copy()
            state_to_save["last_updated"] = datetime.now().isoformat()
            json.dump(state_to_save, f, ensure_ascii=False, indent=2)
    except Exception as e:
        print(f"保存偏好失败: {e}")

def load_preferences_from_file():
    """从文件加载用户偏好"""
    try:
        with open("user_preferences.json", "r", encoding="utf-8") as f:
            return json.load(f)
    except FileNotFoundError:
        return default_preferences.copy()
    except Exception as e:
        print(f"加载偏好失败: {e}")
        return default_preferences.copy()

def update_preferences_ui(state):
    """更新偏好设置界面的显示"""
    return [
        state.get("user_name", "访客"),
        state.get("conversation_style", "友好"),
        state.get("language", "中文"),
        state.get("font_size", "中等"),
        state.get("theme", "默认")
    ]

def apply_preferences(user_name, conversation_style, language, font_size, theme, state):
    """应用用户修改的偏好设置"""
    state["user_name"] = user_name
    state["conversation_style"] = conversation_style
    state["language"] = language
    state["font_size"] = font_size
    state["theme"] = theme
    state["last_updated"] = datetime.now().isoformat()
    
    # 保存到文件
    save_preferences_to_file(state)
    
    return state, "偏好设置已保存！"

# 创建完整的Gradio应用
with gr.Blocks(title="MiniCPM-o-4.5 AI助手（带记忆功能）", theme=gr.themes.Soft()) as demo:
    
    # 初始化state
    state = gr.State(value=load_preferences_from_file())
    
    gr.Markdown("""
    # 🤖 MiniCPM-o-4.5 AI助手（带记忆功能）
    
    这个AI助手能记住你的偏好，提供个性化的对话体验！
    """)
    
    with gr.Tabs():
        # 标签页1：聊天界面
        with gr.TabItem("💬 聊天"):
            with gr.Row():
                with gr.Column(scale=1):
                    # 用户信息显示
                    gr.Markdown("### 👤 当前用户信息")
                    current_user = gr.Textbox(
                        label="用户名",
                        interactive=False,
                        value=lambda: state.value.get("user_name", "访客")
                    )
                    current_style = gr.Textbox(
                        label="对话风格",
                        interactive=False,
                        value=lambda: state.value.get("conversation_style", "友好")
                    )
                    
                    # 图片上传
                    gr.Markdown("### 🖼️ 上传图片（可选）")
                    image_input = gr.Image(
                        label="上传图片",
                        type="pil",
                        height=200
                    )
                
                with gr.Column(scale=2):
                    # 聊天区域
                    chatbot = gr.Chatbot(
                        label="对话记录",
                        height=400,
                        bubble_full_width=False
                    )
                    
                    with gr.Row():
                        text_input = gr.Textbox(
                            label="输入消息",
                            placeholder="输入你的问题...（试试说'我叫小明'或'请用正式风格'）",
                            scale=4
                        )
                        submit_btn = gr.Button("发送", variant="primary", scale=1)
                    
                    clear_btn = gr.Button("清空对话")
        
        # 标签页2：偏好设置
        with gr.TabItem("⚙️ 偏好设置"):
            gr.Markdown("### 个性化设置")
            
            with gr.Row():
                with gr.Column():
                    user_name_input = gr.Textbox(
                        label="你的名字",
                        placeholder="输入你的名字"
                    )
                    
                    conversation_style_dropdown = gr.Dropdown(
                        label="对话风格",
                        choices=["友好", "正式", "幽默", "简洁"],
                        value="友好"
                    )
                    
                    language_dropdown = gr.Dropdown(
                        label="回复语言",
                        choices=["中文", "英文", "中英混合"],
                        value="中文"
                    )
                
                with gr.Column():
                    font_size_dropdown = gr.Dropdown(
                        label="字体大小",
                        choices=["小", "中等", "大", "特大"],
                        value="中等"
                    )
                    
                    theme_dropdown = gr.Dropdown(
                        label="界面主题",
                        choices=["默认", "浅色", "深色"],
                        value="默认"
                    )
            
            save_btn = gr.Button("保存设置", variant="primary")
            status_text = gr.Textbox(label="状态", interactive=False)
            
            # 加载当前设置到UI
            demo.load(
                fn=lambda s: update_preferences_ui(s),
                inputs=[state],
                outputs=[
                    user_name_input,
                    conversation_style_dropdown,
                    language_dropdown,
                    font_size_dropdown,
                    theme_dropdown
                ]
            )
    
    # 聊天功能的事件处理
    def process_message(message, history, image, current_state):
        """处理用户消息"""
        if not message.strip():
            return history, current_state, ""
        
        # 更新用户信息显示
        user_name = current_state.get("user_name", "访客")
        style = current_state.get("conversation_style", "友好")
        
        # 检查是否在设置用户名
        if message.startswith("我叫") or message.startswith("我的名字是"):
            name_part = message.split("我叫")[1] if "我叫" in message else message.split("我的名字是")[1]
            name = name_part.split("。")[0].split("，")[0].strip()
            current_state["user_name"] = name
            response = f"好的，我记住你的名字是{name}了！以后我就这样称呼你。"
        
        # 检查是否在设置对话风格
        elif "正式风格" in message or "正式一点" in message:
            current_state["conversation_style"] = "正式"
            response = "已切换到正式对话风格。"
        elif "幽默风格" in message or "幽默一点" in message:
            current_state["conversation_style"] = "幽默"
            response = "已切换到幽默对话风格，准备好笑一笑吧！"
        elif "友好风格" in message:
            current_state["conversation_style"] = "友好"
            response = "已切换到友好对话风格。"
        
        # 普通对话
        else:
            # 这里应该调用实际的MiniCPM模型
            # 为了演示，我们返回一个模拟回复
            if style == "正式":
                response = f"{user_name}，关于您提出的'{message}'，我的分析如下：这是一个很好的问题，涉及多个方面..."
            elif style == "幽默":
                response = f"{user_name}，你问'{message}'？哈哈，这个问题让我想起了...（开个玩笑）其实呢..."
            else:
                response = f"{user_name}，你问的'{message}'很有意思！我的看法是..."
        
        # 如果有图片，添加图片相关回复
        if image is not None:
            response += "\n\n（我看到了你上传的图片，正在分析图片内容...）"
        
        # 更新历史
        history.append((message, response))
        
        # 保存偏好
        save_preferences_to_file(current_state)
        
        return history, current_state, ""
    
    # 绑定事件
    submit_btn.click(
        fn=process_message,
        inputs=[text_input, chatbot, image_input, state],
        outputs=[chatbot, state, text_input]
    ).then(
        fn=lambda: update_preferences_ui(state.value),
        inputs=[],
        outputs=[current_user, current_style]
    )
    
    # 清空对话（但不清除用户偏好）
    def clear_chat(history, current_state):
        return [], current_state
    
    clear_btn.click(
        fn=clear_chat,
        inputs=[chatbot, state],
        outputs=[chatbot, state]
    )
    
    # 保存偏好设置
    save_btn.click(
        fn=apply_preferences,
        inputs=[
            user_name_input,
            conversation_style_dropdown,
            language_dropdown,
            font_size_dropdown,
            theme_dropdown,
            state
        ],
        outputs=[state, status_text]
    )
    
    # 回车键发送消息
    text_input.submit(
        fn=process_message,
        inputs=[text_input, chatbot, image_input, state],
        outputs=[chatbot, state, text_input]
    )

# 启动应用
if __name__ == "__main__":
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False
    )

5. 功能演示与实际效果

5.1 基本使用演示

现在让我们看看这个带记忆功能的AI助手怎么用：

1. 第一次打开应用：

   • AI会显示“你好访客！”（因为还不知道你的名字）
   • 所有设置都是默认值

2. 告诉AI你的名字：

   • 在聊天框输入：“我叫小明”
   • AI回复：“好的，我记住你的名字是小明了！以后我就这样称呼你。”
   • 左上角的“用户名”会自动更新为“小明”

3. 切换对话风格：

   • 输入：“请用正式风格”
   • AI回复：“已切换到正式对话风格。”
   • 之后的对话都会用正式的语气

4. 在设置页面修改偏好：

   • 点击“偏好设置”标签页
   • 修改名字、风格、语言等选项
   • 点击“保存设置”
   • 回到聊天页面，所有设置立即生效

5.2 跨会话记忆测试

这才是最酷的部分！试试这些操作：

1. 设置个性化偏好：

   # 你在聊天中说：
   "我叫李华，请用幽默风格"
   
   # AI回复：
   "好的，我记住你的名字是李华了！已切换到幽默对话风格，准备好笑一笑吧！"
   

2. 刷新页面或重新打开浏览器：

   • 完全关闭浏览器
   • 重新打开 http://localhost:7860
   • AI还是会说：“你好李华！”（它记得你！）
   • 对话风格仍然是幽默的

3. 查看保存的偏好文件： 在服务器上，你会看到一个user_preferences.json文件：

   {
     "user_name": "李华",
     "conversation_style": "幽默",
     "language": "中文",
     "font_size": "中等",
     "theme": "默认",
     "conversation_history": [
       ["我叫李华，请用幽默风格", "好的，我记住你的名字是李华了！已切换到幽默对话风格..."],
       ["今天天气怎么样？", "李华，你问今天天气怎么样？哈哈，这个问题让我想起了..."]
     ],
     "important_topics": [],
     "last_updated": "2024-01-15T10:30:00.123456"
   }
   

5.3 实际应用场景

这个记忆功能在实际中特别有用：

场景一：教育辅导

• 学生告诉AI：“我是三年级的小明，数学不太好”
• AI记住后，每次对话都会用适合三年级的方式讲解数学
• 还能记住学生常错的知识点，针对性辅导

场景二：客服助手

• 用户说：“我是VIP客户张先生”
• AI立即切换更尊重的服务语气
• 记住用户的历史问题，避免重复询问

场景三：创意写作

• 作者说：“我在写科幻小说，主角叫林风”
• AI记住故事背景和人物
• 后续对话中能保持故事一致性

6. 高级功能与优化建议

6.1 持久化存储优化

上面的例子用了JSON文件存储，对于个人使用足够了。但如果多人使用，或者需要更可靠，可以考虑：

# 使用SQLite数据库（更可靠）
import sqlite3
import hashlib

def get_user_id(session_id):
    """根据会话ID生成用户ID"""
    return hashlib.md5(session_id.encode()).hexdigest()[:8]

def save_preferences_to_db(user_id, preferences):
    """保存到SQLite数据库"""
    conn = sqlite3.connect('user_preferences.db')
    cursor = conn.cursor()
    
    # 创建表（如果不存在）
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS preferences (
            user_id TEXT PRIMARY KEY,
            preferences TEXT,
            last_updated TIMESTAMP
        )
    ''')
    
    # 插入或更新
    cursor.execute('''
        INSERT OR REPLACE INTO preferences (user_id, preferences, last_updated)
        VALUES (?, ?, ?)
    ''', (user_id, json.dumps(preferences), datetime.now().isoformat()))
    
    conn.commit()
    conn.close()

# 在Gradio中获取会话ID
def get_session_id():
    """获取当前会话ID（需要Gradio的上下文）"""
    # 实际实现需要根据Gradio版本调整
    return "session_123"  # 示例

6.2 记忆容量管理

如果对话历史太长，会占用太多内存。我们可以实现自动清理：

def manage_memory(state, max_history=50, max_topics=20):
    """管理记忆容量，避免无限增长"""
    
    # 限制对话历史长度
    if len(state.get("conversation_history", [])) > max_history:
        state["conversation_history"] = state["conversation_history"][-max_history:]
    
    # 限制重要话题数量
    if len(state.get("important_topics", [])) > max_topics:
        state["important_topics"] = state["important_topics"][-max_topics:]
    
    # 定期清理过时记忆（比如30天前的）
    current_time = datetime.now()
    if "memory_entries" in state:
        state["memory_entries"] = [
            entry for entry in state["memory_entries"]
            if (current_time - datetime.fromisoformat(entry["timestamp"])).days < 30
        ]
    
    return state

6.3 智能偏好学习

让AI能自动学习用户偏好：

def learn_user_preferences(message, response, state):
    """从对话中自动学习用户偏好"""
    
    # 检测用户可能喜欢的风格
    if "谢谢" in message or "感谢" in message:
        # 用户礼貌，可能喜欢正式风格
        if state.get("conversation_style") != "正式":
            state["preferred_style_hint"] = "formal"
    
    # 检测用户专业领域
    technical_terms = ["代码", "编程", "算法", "模型", "训练"]
    if any(term in message for term in technical_terms):
        state["user_interests"].append("技术")
    
    # 检测对话频率
    if "conversation_count" not in state:
        state["conversation_count"] = 0
    state["conversation_count"] += 1
    
    # 根据对话次数调整熟悉程度
    if state["conversation_count"] > 10:
        state["familiarity_level"] = "高"
    elif state["conversation_count"] > 3:
        state["familiarity_level"] = "中"
    else:
        state["familiarity_level"] = "低"
    
    return state

6.4 多用户支持

如果需要支持多个用户同时使用：

# 使用字典存储多个用户的state
user_states = {}

def get_or_create_user_state(session_id):
    """获取或创建用户的state"""
    if session_id not in user_states:
        # 尝试从数据库加载
        user_state = load_user_state_from_db(session_id)
        if user_state is None:
            user_state = default_preferences.copy()
        user_states[session_id] = user_state
    
    return user_states[session_id]

# 在聊天函数中使用
def chat_with_ai_for_user(message, history, session_id):
    user_state = get_or_create_user_state(session_id)
    # ... 使用user_state进行对话

7. 常见问题与解决方案

7.1 state不工作怎么办？

问题：设置了state，但刷新页面后数据还是丢失了。

检查步骤：

1. 确认state正确传递：

   # 在函数中添加打印调试
   def chat_function(message, state):
       print(f"当前state: {state}")  # 查看state是否正常传入
       # ... 其他代码
   

2. 检查JSON文件权限：

   # 确保有写入权限
   ls -la user_preferences.json
   chmod 644 user_preferences.json  # 如果需要
   

3. 验证文件读写：

   # 添加错误处理
   try:
       with open("user_preferences.json", "w") as f:
           json.dump(state, f)
   except Exception as e:
       print(f"写入失败: {e}")
       # 尝试其他位置
       with open("/tmp/user_preferences.json", "w") as f:
           json.dump(state, f)
   

7.2 性能优化建议

如果感觉应用变慢，可以尝试：

1. 限制历史记录长度：

   # 只保留最近50条消息
   if len(state["conversation_history"]) > 50:
       state["conversation_history"] = state["conversation_history"][-50:]
   

2. 异步保存：

   import asyncio
   
   async def save_preferences_async(state):
       """异步保存，不阻塞主线程"""
       await asyncio.sleep(0)  # 让出控制权
       with open("user_preferences.json", "w") as f:
           json.dump(state, f)
   

3. 使用更高效的数据结构：

   # 使用deque限制长度
   from collections import deque
   
   state["conversation_history"] = deque(maxlen=100)
   

7.3 安全考虑

存储用户数据时要注意安全：

1. 不存储敏感信息：

   # 避免存储这些
   sensitive_keys = ["password", "credit_card", "phone", "email", "address"]
   for key in sensitive_keys:
       if key in state:
           del state[key]
   

2. 数据加密（如果需要）：

   from cryptography.fernet import Fernet
   
   # 生成密钥（实际应该安全存储）
   key = Fernet.generate_key()
   cipher = Fernet(key)
   
   # 加密数据
   encrypted_data = cipher.encrypt(json.dumps(state).encode())
   
   # 解密数据
   decrypted_data = cipher.decrypt(encrypted_data)
   state = json.loads(decrypted_data.decode())
   

8. 总结

通过这篇文章，我们为MiniCPM-o-4.5-nvidia-FlagOS AI助手添加了记忆功能。现在它不仅能看能说，还能记住你的偏好，提供真正个性化的服务。

关键收获：

1. Gradio的state组件是存储会话状态的神器，简单易用
2. JSON文件存储实现了跨会话记忆，刷新页面也不怕
3. 个性化体验让AI更像一个真正的助手，而不是冰冷的机器
4. 扩展性强，你可以根据需要添加更多记忆维度

实际价值：

• 对于用户：每次对话都是连续的体验，不用重复自我介绍
• 对于开发者：为应用增加独特卖点，提升用户粘性
• 对于产品：从工具升级为伙伴，创造情感连接

下一步你可以尝试：

• 添加更多记忆维度：记住用户的兴趣爱好、专业领域
• 实现智能学习：让AI自动从对话中学习用户偏好
• 添加导出功能：让用户备份自己的对话记忆
• 实现多设备同步：让记忆在手机、电脑间同步

记忆功能让AI助手从“一次性工具”变成了“长期伙伴”。每次对话都在加深了解，每次互动都在积累默契。这才是AI应用的未来方向——不是替代人类，而是理解人类，服务人类。

现在就去试试吧，给你的AI助手装上“记忆”，看看它能为你记住什么！

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。