🎯 今日核心问题

  1. 用户说「帮我用 Python 写个脚本」,这算他的技术栈偏好,还是一次性需求?
  2. 抽取为什么不能放在每一轮对话的同步链路里?
  3. 画像塞进 system prompt,怎么防止它盖过本轮任务指令?

📖 精读提纲

【一】进画像的门槛:稳定性 + 可复用性

画像的定义决定了它的边界——画像只存「下次对话开始时仍然为真」的信息。三条准入规则可以挡住绝大多数噪声:一是稳定,跨会话仍然成立(「母语中文」成立,「今天要个旅行攻略」不成立);二是可复用,会影响未来的默认决策(「偏好简洁回答、不要分点」成立,「这篇文档要 800 字」不成立);三是有据,能从原话里指出依据,不是模型推理出来的(「他大概是后端工程师」不算,「他明确说自己做 Java 后端」才算)。

常见的误收三类:一次性任务参数(预算、字数、日期)、情绪与临时状态(「今天有点烦,别废话」是当轮风格指令)、模型推断的身份。容易漏收的是隐性偏好:用户连续三次把输出从表格改成列表、连续两次要求「不要加总结段」,这类行为信号比口头声明更可靠,值得单独一条抽取通道。

还有一点:画像要支持负面偏好。「不喜欢 emoji」「不要用『赋能』『闭环』」比正面偏好更有用,因为模型默认行为就是加 emoji、加总结。

【二】异步抽取:挂在会话结束后,不挂在每轮

实时抽取有三个代价:每轮多一次 LLM 调用(延迟直接加在用户等待上)、单轮信息量太小(一句话不足以判断稳定性)、大量重复写入(同一偏好被反复覆盖,版本链迅速膨胀)。

正确时机是会话结束或空闲后:超过 10 分钟无消息、或累计满 8 轮、或用户显式关闭,触发一次异步任务。输入不是全量历史,而是「本次会话摘要 + 上一版画像」,任务是增量合并而非从头生成——输出小、成本低,且天然带上「什么没变」的信息。抽取结果走 D5 的 upsert,冲突由版本链消化。

工程上防三件事:并发重复触发(pg_try_advisory_lock 幂等锁)、抽取失败静默(重试队列 + 死信表)、以及用户可见可编辑。画像必须有「我的偏好」页面能看能改——模型推断的东西一定有错,不给修改入口就是积累错误。

【三】结构化字段 vs 自然语言摘要

结构化字段(language、tech_stack[]、response_style、forbidden_terms[])适合被程序消费:做路由(Java 用户走 Java 模板)、填默认值、A/B 分群、冲突检测。缺点是装不下「他习惯先要结论再要论证」这种细腻描述。

自然语言摘要(200-400 字一段话)适合直接注入 prompt:信息密度高、能承载语气和隐性习惯。缺点是不可查询、不可比较,且随每次合并越写越长。

生产做法是两者并存:结构化字段作为事实源,摘要由字段 + 最近会话渲染生成,不独立存储、不独立演化,避免「摘要和字段说的是两件事」的分裂。摘要硬性限制 300 字——放任增长,两三个月后 system prompt 会被画像占满。

【四】注入姿态:背景板,不是主角

四条规则:一是放在 system prompt 末尾段,紧邻本轮消息,权重更高但语义上明确从属;二是用「背景参考」而非「必须遵守」的措辞,只在硬约束(禁用词、语言)上用强制语气;三是显式声明优先级——「若与本轮指令冲突,以本轮指令为准」,这一句解决 80% 的画像污染;四是控制体积,画像段落不超过 system prompt 的三分之一。

另一个细节:选择性注入。写代码注入技术栈和代码风格,写文案注入语气和禁用词,闲聊只注入风格。全量注入既费 token 又增加干扰。

💻 代码示例

LangChain4j 的 AiServices 做结构化输出抽取,Jackson 落库,PromptBuilder 负责选择性注入。

package com.example.profile;

import com.fasterxml.jackson.databind.ObjectMapper;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.output.structured.Description;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserProfileExtractor {

    public static class ProfileDelta {
        @Description("用户主要使用的编程语言,如 Java/Python/TypeScript;未明确提及则为 null")
        public String primaryLanguage;

        @Description("用户明确提到的技术栈,如 Spring Boot、React;只收明确陈述的")
        public List<String> techStack;

        @Description("回答风格偏好:CONCISE 或 DETAILED;未提及为 null")
        public String responseStyle;

        @Description("用户明确表示不喜欢或禁止出现的词/格式")
        public List<String> forbiddenTerms;

        @Description("稳定的其他偏好,一句话一条,每条不超过 30 字")
        public List<String> otherPreferences;

        @Description("本次对话中出现但不属于长期偏好的内容,仅用于说明为何丢弃")
        public List<String> rejectedAsEphemeral;
    }

    interface Extractor {
        @SystemMessage("""
            你从对话中抽取用户的【长期稳定偏好】,用于写入用户画像。
            准入规则:
            1. 跨会话仍然成立;2. 影响未来默认决策;3. 有原话依据,不做身份推断。
            禁止收录:一次性任务参数(预算/字数/日期/文件名)、临时情绪、模型推测。
            只输出结构化结果,不要解释。
            """)
        ProfileDelta extract(@UserMessage String payload);
    }

    private final Extractor extractor;
    private final JdbcTemplate jdbc;
    private final ObjectMapper mapper = new ObjectMapper();

    public UserProfileExtractor(ChatLanguageModel model, JdbcTemplate jdbc) {
        this.jdbc = jdbc;
        this.extractor = AiServices.create(Extractor.class, model);
        this.jdbc.execute("""
            CREATE TABLE IF NOT EXISTS user_profile (
                user_id        BIGINT PRIMARY KEY,
                language       VARCHAR(32),
                tech_stack     JSONB NOT NULL DEFAULT '[]',
                response_style VARCHAR(16),
                forbidden_terms JSONB NOT NULL DEFAULT '[]',
                extra_prefs    JSONB NOT NULL DEFAULT '[]',
                version        INT NOT NULL DEFAULT 0,
                last_extracted_at TIMESTAMPTZ,
                updated_at     TIMESTAMPTZ NOT NULL DEFAULT now()
            );
            CREATE TABLE IF NOT EXISTS profile_extract_queue (
                id BIGSERIAL PRIMARY KEY,
                session_id VARCHAR(64) NOT NULL UNIQUE,
                user_id    BIGINT NOT NULL,
                attempts   INT NOT NULL DEFAULT 0,
                payload    TEXT NOT NULL,
                failed_at  TIMESTAMPTZ
            );
            """);
    }

    /** 会话结束/空闲触发,不在对话主链路里 */
    @Async("profileExecutor")
    public void extractAsync(long userId, String sessionId, String summary, String lastProfileJson) {
        Boolean locked = jdbc.queryForObject(
                "SELECT pg_try_advisory_lock(hashtext(?))", Boolean.class, "extract:" + sessionId);
        if (locked == null || !locked) {
            return; // 已有实例在跑
        }
        try {
            String payload = "上一版画像:" + lastProfileJson + "\n本次会话摘要:" + summary;
            ProfileDelta delta = extractor.extract(payload);
            merge(userId, delta);
        } catch (Exception e) {
            jdbc.update("INSERT INTO profile_extract_queue (session_id, user_id, payload) VALUES (?, ?, ?) "
                      + "ON CONFLICT (session_id) DO UPDATE SET attempts = profile_extract_queue.attempts + 1",
                    sessionId, userId, summary);
        } finally {
            jdbc.queryForObject("SELECT pg_advisory_unlock(hashtext(?))", Boolean.class, "extract:" + sessionId);
        }
    }

    private void merge(long userId, ProfileDelta d) {
        jdbc.update(con -> {
            var ps = con.prepareStatement("""
                INSERT INTO user_profile (user_id, language, tech_stack, response_style,
                                          forbidden_terms, extra_prefs, version, last_extracted_at)
                VALUES (?, ?, ?::jsonb, ?, ?::jsonb, ?::jsonb, 1, now())
                ON CONFLICT (user_id) DO UPDATE SET
                    language        = COALESCE(EXCLUDED.language, user_profile.language),
                    tech_stack      = user_profile.tech_stack || EXCLUDED.tech_stack,
                    response_style  = COALESCE(EXCLUDED.response_style, user_profile.response_style),
                    forbidden_terms = user_profile.forbidden_terms || EXCLUDED.forbidden_terms,
                    extra_prefs     = user_profile.extra_prefs || EXCLUDED.extra_prefs,
                    version         = user_profile.version + 1,
                    last_extracted_at = now(),
                    updated_at      = now()
                """);
            ps.setLong(1, userId);
            ps.setString(2, d.primaryLanguage);
            ps.setString(3, json(d.techStack));
            ps.setString(4, d.responseStyle);
            ps.setString(5, json(d.forbiddenTerms));
            ps.setString(6, json(d.otherPreferences));
            return ps;
        });
    }

    private String json(List<String> v) {
        try {
            return mapper.writeValueAsString(v == null ? List.of() : v);
        } catch (Exception e) {
            return "[]";
        }
    }
}
package com.example.profile;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;

@Component
public class PromptBuilder {

    private static final int PROFILE_CHAR_BUDGET = 300;

    private final JdbcTemplate jdbc;

    public PromptBuilder(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }

    /** intent: CODE / WRITING / CHAT —— 按意图选择性注入,避免全量污染 */
    public String build(String baseSystem, long userId, String intent, String userTurn) {
        List<Map<String, Object>> rows = jdbc.queryForList(
                "SELECT language, tech_stack, response_style, forbidden_terms, extra_prefs "
              + "FROM user_profile WHERE user_id = ?", userId);
        if (rows.isEmpty()) {
            return baseSystem;
        }
        Map<String, Object> p = rows.get(0);
        StringBuilder sb = new StringBuilder(baseSystem).append("\n\n## 用户背景(仅作参考,非强制)\n");

        if ("CODE".equals(intent)) {
            append(sb, "主要语言", p.get("language"));
            append(sb, "技术栈", p.get("tech_stack"));
        }
        append(sb, "回答风格", p.get("response_style"));
        if ("CODE".equals(intent) || "WRITING".equals(intent)) {
            Object banned = p.get("forbidden_terms");
            if (banned != null && !"[]".equals(banned.toString())) {
                sb.append("- 禁用词/格式(硬约束):").append(banned).append('\n');
            }
        }
        Object extra = p.get("extra_prefs");
        if (extra != null && !"[]".equals(extra.toString())) {
            sb.append("- 其他稳定偏好:").append(extra).append('\n');
        }

        sb.append("\n若上述背景与用户本轮明确指令冲突,一律以本轮指令为准。\n");
        sb.append("本轮任务:").append(userTurn);

        String out = sb.toString();
        int limit = Math.max(PROFILE_CHAR_BUDGET, baseSystem.length() + 200);
        if (out.length() > limit) {
            return baseSystem + "\n\n## 用户背景(仅作参考,非强制)\n"
                + "- 回答风格:" + p.get("response_style") + "\n"
                + "若上述背景与用户本轮明确指令冲突,一律以本轮指令为准。\n本轮任务:" + userTurn;
        }
        return out;
    }

    private void append(StringBuilder sb, String label, Object value) {
        if (value != null && !"null".equals(value.toString()) && !"[]".equals(value.toString())) {
            sb.append("- ").append(label).append(":").append(value).append('\n');
        }
    }
}

关键设计:tech_stack 用 JSONB 数组拼接(||)而非覆盖,天然支持多值累积;language / response_style 用 COALESCE 保证「本次没提到」不会把已有值清空——这是增量合并最容易写错的地方。抽取失败时 payload 进队列表,由定时任务重放,不会静默丢偏好。

✏️ 今日动手

① 造一段 12 轮对话,其中混入 3 条一次性参数(预算、字数、日期)和 2 条真实偏好,跑抽取验证 rejectedAsEphemeral 是否把噪声识别出来;② 连续跑两次,确认 version 递增但 tech_stack 没出现重复元素(需要给合并加去重,试试 SELECT DISTINCT 包一层);③ 用 build(..., "CHAT", ...) 和 "CODE" 对比注入结果,确认闲聊时不注入技术栈;④ 故意让模型超时,检查 profile_extract_queue 是否落了一条待重放记录。

🔖 明日预告

一周下来,短记忆、长记忆、画像三层都齐了。明天做周总结,把三层合成一个能跨会话记住用户的 MemoryService,并给出完整装配代码。