【自学AI】09 让 AI 记住你说过的话——多轮对话与会话管理实战

1
import { Injectable, Logger } from '@nestjs/common';
2
import { v4 as uuidv4 } from 'uuid';
3
import { Message, SessionData } from '../interfaces/message.interface';
4

5
@Injectable()
6
export class SessionManager {
7
  private readonly logger = new Logger(SessionManager.name);
8

9
  // 用 Map 存储所有会话，key 是 sessionId
10
  // 注意：这是内存存储，服务器重启会丢失
11
  // 生产环境应该持久化到数据库（下一篇会讲）
12
  private sessions: Map<string, SessionData> = new Map();
13

14
  /**
15
   * 创建新会话
16
   *
17
   * @param userId 用户 ID
18
   * @param position 面试职位
19
   * @param systemMessage AI 的角色定义（System Message）
20
   * @returns 新会话的 sessionId
21
   */
22
  createSession(
23
    userId: string,
24
    position: string,
25
    systemMessage: string,
26
  ): string {
27
    const sessionId = uuidv4();
28

29
    const session: SessionData = {
30
      sessionId,
31
      userId,
32
      position,
33
      messages: [
34
        {
35
          role: 'system',
36
          content: systemMessage,
37
        },
38
      ],
39
      createdAt: new Date(),
40
      lastActivityAt: new Date(),
41
    };
42

43
    this.sessions.set(sessionId, session);
44
    this.logger.log(`创建会话: ${sessionId}，用户: ${userId}`);
45

46
    return sessionId;
47
  }
48

49
  /**
50
   * 向会话中添加一条消息
51
   *
52
   * @param sessionId 会话 ID
53
   * @param role 消息角色
54
   * @param content 消息内容
55
   */
56
  addMessage(
57
    sessionId: string,
58
    role: 'user' | 'assistant',
59
    content: string,
60
  ): void {
61
    const session = this.sessions.get(sessionId);
62

63
    if (!session) {
64
      throw new Error(`会话不存在: ${sessionId}`);
65
    }
66

67
    session.messages.push({ role, content });
68
    session.lastActivityAt = new Date(); // 更新最后活跃时间
69
  }
70

71
  /**
72
   * 获取会话的完整对话历史
73
   *
74
   * @param sessionId 会话 ID
75
   * @returns Message 数组
76
   */
77
  getHistory(sessionId: string): Message[] {
78
    const session = this.sessions.get(sessionId);
79
    return session?.messages || [];
80
  }
81

82
  /**
83
   * 获取最近的 N 条消息（用于控制 Token 消耗）
84
   *
85
   * 为什么需要这个方法？
86
   * 对话越长，每次发给 AI 的 token 就越多，成本越高。
87
   * 所以我们只保留最近的几条消息，旧的消息可以丢弃。
88
   *
89
   * 但有一个例外：System Message（第一条）必须始终保留。
90
   * 因为它定义了 AI 的角色，丢掉它 AI 就不知道自己是谁了。
91
   *
92
   * @param sessionId 会话 ID
93
   * @param count 保留最近几条消息（不含 System Message）
94
   */
95
  getRecentMessages(sessionId: string, count: number = 10): Message[] {
96
    const history = this.getHistory(sessionId);
97

98
    if (history.length === 0) {
99
      return [];
100
    }
101

102
    // System Message 是第一条，必须保留
103
    const systemMessage = history[0];
104

105
    // 取最近 count 条消息
106
    const recentMessages = history.slice(-count);
107

108
    // 如果最近的消息里已经包含了 System Message，直接返回
109
    if (recentMessages[0]?.role === 'system') {
110
      return recentMessages;
111
    }
112

113
    // 否则，在最前面加上 System Message
114
    return [systemMessage, ...recentMessages];
115
  }
116

117
  /**
118
   * 结束会话，从内存中删除
119
   *
120
   * @param sessionId 会话 ID
121
   */
122
  endSession(sessionId: string): void {
123
    if (this.sessions.has(sessionId)) {
124
      this.sessions.delete(sessionId);
125
      this.logger.log(`结束会话: ${sessionId}`);
126
    }
127
  }
128

129
  /**
130
   * 清理超过 1 小时未活动的过期会话
131
   *
132
   * 在生产环境中，应该用 @Cron 装饰器定期调用这个方法，
133
   * 防止内存无限增长。
134
   */
135
  cleanupExpiredSessions(): void {
136
    const now = new Date();
137
    const expirationTime = 60 * 60 * 1000; // 1 小时
138

139
    for (const [sessionId, session] of this.sessions.entries()) {
140
      if (now.getTime() - session.lastActivityAt.getTime() > expirationTime) {
141
        this.sessions.delete(sessionId);
142
        this.logger.warn(`清理过期会话: ${sessionId}`);
143
      }
144
    }
145
  }
146
}

1
/**
2
 * 简历分析的 System Message
3
 * 定义 AI 的角色，根据职位动态生成
4
 */
5
export const RESUME_ANALYSIS_SYSTEM_MESSAGE = (position: string): string => {
6
  return `你是一个资深的 ${position} 面试官，有 15 年的招聘经验。你能快速从简历中识别候选人的核心能力。`;
7
};
8

9
/**
10
 * 简历分析的主 Prompt
11
 * 用于第一次分析简历，返回结构化的 JSON 报告
12
 */
13
export const RESUME_ANALYSIS_PROMPT = `
14
你已经拥有以下信息，要求你进行分析：
15

16
## 简历内容
17

18
{resume_content}
19

20
## 岗位要求
21

22
{job_description}
23

24
## 分析要求
25

26
1. 提取候选人的：
27
   - 工作年限
28
   - 主要技能
29
   - 最近工作经历
30
   - 教育背景
31

32
2. 评估匹配度（0-100）
33

34
3. 识别优势和不足
35

36
## 输出格式（JSON）
37

38
{{
39
  "years_of_experience": 数字,
40
  "skills": ["技能1", "技能2"],
41
  "recent_position": "最近的职位",
42
  "education": "学历",
43
  "match_score": 数字（0-100）,
44
  "strengths": ["优势1", "优势2"],
45
  "gaps": ["缺陷1", "缺陷2"],
46
  "summary": "1-2 句总结"
47
}}
48
`;
49

50
/**
51
 * 多轮对话继续的 Prompt
52
 * 用于后续追问，基于已有的对话历史回答
53
 */
54
export const CONVERSATION_CONTINUATION_PROMPT = `基于以下对话历史，请回答最后一个问题。
55

56
对话历史：
57
{history}
58

59
请给出清晰、有逻辑的回答。`;

1
import { Injectable, Logger } from '@nestjs/common';
2
import { SessionManager } from '../../ai/services/session.manager';
3
import { AIModelFactory } from '../../ai/services/ai-model.factory';
4
import { ResumeAnalysisService } from './resume-analysis.service';
5
import { ConversationContinuationService } from './conversation-continuation.service';
6
import { RESUME_ANALYSIS_SYSTEM_MESSAGE } from '../prompts/resume-analysis.prompts';
7

8
@Injectable()
9
export class InterviewService {
10
  private readonly logger = new Logger(InterviewService.name);
11

12
  constructor(
13
    private sessionManager: SessionManager,
14
    private aiModelFactory: AIModelFactory,
15
    private resumeAnalysisService: ResumeAnalysisService,
16
    private conversationContinuationService: ConversationContinuationService,
17
  ) {}
18

19
  /**
20
   * 分析简历（第一轮对话）
21
   * 创建新会话，调用 AI 分析，保存历史
22
   */
23
  async analyzeResume(
24
    userId: string,
25
    position: string,
26
    resumeContent: string,
27
    jobDescription: string,
28
  ) {
29
    try {
30
      // 第一步：创建新会话，写入 System Message
31
      const systemMessage = RESUME_ANALYSIS_SYSTEM_MESSAGE(position);
32
      const sessionId = this.sessionManager.createSession(
33
        userId,
34
        position,
35
        systemMessage,
36
      );
37

38
      this.logger.log(`创建会话: ${sessionId}`);
39

40
      // 第二步：调用简历分析服务
41
      const result = await this.resumeAnalysisService.analyze(
42
        resumeContent,
43
        jobDescription,
44
      );
45

46
      // 第三步：把这轮对话保存到会话历史
47
      this.sessionManager.addMessage(
48
        sessionId,
49
        'user',
50
        `简历内容：${resumeContent}`,
51
      );
52
      this.sessionManager.addMessage(
53
        sessionId,
54
        'assistant',
55
        JSON.stringify(result),
56
      );
57

58
      this.logger.log(`简历分析完成，sessionId: ${sessionId}`);
59

60
      return { sessionId, analysis: result };
61
    } catch (error) {
62
      this.logger.error(`分析简历失败: ${error}`);
63
      throw error;
64
    }
65
  }
66

67
  /**
68
   * 继续对话（多轮）
69
   * 基于已有会话，追加新消息，调用 AI 回答
70
   */
71
  async continueConversation(
72
    sessionId: string,
73
    userQuestion: string,
74
  ): Promise<string> {
75
    try {
76
      // 第一步：把用户的新问题加入历史
77
      this.sessionManager.addMessage(sessionId, 'user', userQuestion);
78

79
      // 第二步：取最近 10 条消息（含 System Message）
80
      const history = this.sessionManager.getRecentMessages(sessionId, 10);
81

82
      this.logger.log(
83
        `继续对话，sessionId: ${sessionId}，历史消息数: ${history.length}`,
84
      );
85

86
      // 第三步：调用对话继续服务
87
      const aiResponse =
88
        await this.conversationContinuationService.continue(history);
89

90
      // 第四步：把 AI 的回答也保存到历史
91
      this.sessionManager.addMessage(sessionId, 'assistant', aiResponse);
92

93
      this.logger.log(`对话继续完成，sessionId: ${sessionId}`);
94

95
      return aiResponse;
96
    } catch (error) {
97
      this.logger.error(`继续对话失败: ${error}`);
98
      throw error;
99
    }
100
  }
101
}