ChatGPT登录后聊天记录丢失问题分析与实战解决方案

最近在开发一个集成ChatGPT API的对话应用时，遇到了一个让人头疼的问题：用户每次刷新页面或重新登录后，之前的聊天记录就全部消失了。这就像每次打电话都要重新自我介绍一样，用户体验大打折扣。

1. 问题根源分析

为什么ChatGPT API集成会出现会话丢失问题？这要从几个层面来看：

前端层面：大多数开发者直接在前端调用API，会话状态保存在内存中，页面刷新自然就清空了。

API设计层面：OpenAI的ChatGPT API本身是无状态的，每次请求都是独立的，除非你显式地传递历史对话。

架构层面：没有建立完整的会话管理体系，用户身份和对话历史没有持久化存储。

这种问题在以下场景尤其明显：

• 用户不小心刷新了页面
• 移动端应用切换到后台再回来
• 多标签页同时使用同一个应用
• 用户在不同设备间切换

2. 会话管理方案对比

要解决这个问题，我们需要选择合适的会话存储方案。下面是我对各种方案的对比分析：

2.1 localStorage方案

优点：

• 存储容量大（通常5-10MB）
• 不会随HTTP请求自动发送，安全性相对较好
• 操作简单，纯前端实现

缺点：

• 同源策略限制，无法跨域共享
• 移动端WebView中可能被清除
• 数据未加密，存在安全风险

2.2 Cookie方案

优点：

• 自动随请求发送，服务端可直接读取
• 可设置过期时间
• 支持跨域（需正确配置）

缺点：

• 存储容量小（约4KB）
• 每次请求都会携带，增加带宽消耗
• 需要防范CSRF攻击

2.3 JWT（JSON Web Token）方案

优点：

• 无状态，服务端无需存储会话
• 可包含用户信息和权限
• 支持跨域和分布式系统

缺点：

• 令牌一旦签发，在有效期内无法撤销
• 令牌泄露存在安全风险
• 需要妥善管理密钥

2.4 服务端缓存方案

优点：

• 数据安全，客户端无法直接访问
• 可集中管理，支持多设备同步
• 可设置复杂的过期策略

缺点：

• 增加服务端复杂度
• 需要维护会话存储（如Redis）
• 网络延迟可能影响体验

3. 混合存储架构实现

基于以上分析，我设计了一个混合存储方案：JWT + localStorage + 服务端缓存。这个方案结合了各种存储方式的优点，下面用Node.js + Express来演示具体实现。

3.1 项目结构

chatgpt-session-demo/
├── server/
│   ├── app.js          # Express应用入口
│   ├── middleware/     # 中间件
│   │   └── auth.js     # JWT验证中间件
│   ├── routes/         # 路由
│   │   └── session.js  # 会话管理路由
│   └── utils/          # 工具函数
│       └── crypto.js   # 加密工具
├── client/
│   └── index.html      # 前端页面
└── package.json

3.2 服务端实现

首先安装必要的依赖：

npm install express jsonwebtoken bcryptjs crypto-js cors dotenv

app.js - 主应用文件

import express from 'express';
import cors from 'cors';
import dotenv from 'dotenv';
import sessionRoutes from './routes/session.js';
import { authenticateToken } from './middleware/auth.js';

dotenv.config();

const app = express();
const PORT = process.env.PORT || 3000;

// 中间件配置
app.use(cors({
  origin: process.env.CLIENT_URL || 'http://localhost:8080',
  credentials: true
}));
app.use(express.json());

// 路由配置
app.use('/api/session', sessionRoutes);

// 受保护的路由示例
app.get('/api/chat/history', authenticateToken, (req, res) => {
  // 这里可以获取用户的聊天历史
  res.json({ 
    userId: req.user.id,
    history: [] // 实际应从数据库获取
  });
});

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

utils/crypto.js - 加密工具

import crypto from 'crypto';

/**
 * 生成随机的加密密钥
 * @returns {string} 32字节的十六进制密钥
 */
export function generateEncryptionKey() {
  return crypto.randomBytes(32).toString('hex');
}

/**
 * 使用AES-256-CBC加密数据
 * @param {string} text - 要加密的文本
 * @param {string} key - 加密密钥（32字节）
 * @returns {Object} 包含iv和encryptedData的对象
 */
export function encryptData(text, key) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(key, 'hex'), iv);
  
  let encrypted = cipher.update(text, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  
  return {
    iv: iv.toString('hex'),
    encryptedData: encrypted
  };
}

/**
 * 解密AES-256-CBC加密的数据
 * @param {Object} encrypted - 加密对象 {iv, encryptedData}
 * @param {string} key - 解密密钥
 * @returns {string} 解密后的文本
 */
export function decryptData(encrypted, key) {
  const decipher = crypto.createDecipheriv(
    'aes-256-cbc',
    Buffer.from(key, 'hex'),
    Buffer.from(encrypted.iv, 'hex')
  );
  
  let decrypted = decipher.update(encrypted.encryptedData, 'hex', 'utf8');
  decrypted += decipher.final('utf8');
  
  return decrypted;
}

middleware/auth.js - JWT验证中间件

import jwt from 'jsonwebtoken';

/**
 * JWT令牌验证中间件
 * @param {Object} req - Express请求对象
 * @param {Object} res - Express响应对象
 * @param {Function} next - 下一个中间件函数
 */
export function authenticateToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];

  if (!token) {
    return res.status(401).json({ error: '访问令牌缺失' });
  }

  jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
    if (err) {
      return res.status(403).json({ error: '令牌无效或已过期' });
    }
    
    req.user = user;
    next();
  });
}

/**
 * 生成JWT令牌
 * @param {Object} user - 用户信息
 * @returns {string} JWT令牌
 */
export function generateAccessToken(user) {
  return jwt.sign(
    { 
      id: user.id, 
      username: user.username,
      exp: Math.floor(Date.now() / 1000) + (15 * 60) // 15分钟过期
    },
    process.env.JWT_SECRET
  );
}

/**
 * 生成刷新令牌
 * @param {Object} user - 用户信息
 * @returns {string} 刷新令牌
 */
export function generateRefreshToken(user) {
  return jwt.sign(
    { 
      id: user.id,
      exp: Math.floor(Date.now() / 1000) + (7 * 24 * 60 * 60) // 7天过期
    },
    process.env.JWT_REFRESH_SECRET
  );
}

routes/session.js - 会话管理路由

import express from 'express';
import { 
  generateAccessToken, 
  generateRefreshToken 
} from '../middleware/auth.js';
import { encryptData } from '../utils/crypto.js';

const router = express.Router();

// 模拟用户数据库
const users = [
  { id: 1, username: 'user1', password: 'hashed_password_1' },
  { id: 2, username: 'user2', password: 'hashed_password_2' }
];

// 模拟会话存储（生产环境应使用Redis或数据库）
const sessions = new Map();

/**
 * 用户登录并创建会话
 */
router.post('/login', (req, res) => {
  const { username, password } = req.body;
  
  // 实际项目中应该验证密码哈希
  const user = users.find(u => u.username === username);
  
  if (!user) {
    return res.status(401).json({ error: '用户名或密码错误' });
  }

  // 生成令牌
  const accessToken = generateAccessToken(user);
  const refreshToken = generateRefreshToken(user);
  
  // 生成客户端加密密钥
  const clientKey = generateEncryptionKey();
  
  // 存储会话信息（生产环境应存到Redis）
  sessions.set(user.id, {
    refreshToken,
    clientKey,
    lastActivity: Date.now()
  });

  // 加密客户端密钥（用于安全传输）
  const encryptedKey = encryptData(clientKey, process.env.SERVER_KEY);

  res.json({
    accessToken,
    refreshToken,
    encryptedKey: encryptedKey.encryptedData,
    iv: encryptedKey.iv,
    user: {
      id: user.id,
      username: user.username
    }
  });
});

/**
 * 刷新访问令牌
 */
router.post('/refresh', (req, res) => {
  const { refreshToken } = req.body;
  
  if (!refreshToken) {
    return res.status(401).json({ error: '刷新令牌缺失' });
  }

  jwt.verify(refreshToken, process.env.JWT_REFRESH_SECRET, (err, user) => {
    if (err) {
      return res.status(403).json({ error: '刷新令牌无效' });
    }

    const session = sessions.get(user.id);
    if (!session || session.refreshToken !== refreshToken) {
      return res.status(403).json({ error: '会话已失效' });
    }

    // 生成新的访问令牌
    const accessToken = generateAccessToken(user);
    
    // 更新会话活动时间
    session.lastActivity = Date.now();
    sessions.set(user.id, session);

    res.json({ accessToken });
  });
});

/**
 * 获取用户会话状态
 */
router.get('/status', authenticateToken, (req, res) => {
  const session = sessions.get(req.user.id);
  
  if (!session) {
    return res.status(404).json({ error: '会话不存在' });
  }

  res.json({
    userId: req.user.id,
    lastActivity: session.lastActivity,
    isActive: Date.now() - session.lastActivity < 30 * 60 * 1000 // 30分钟不活动视为失效
  });
});

export default router;

3.3 客户端实现

前端会话管理类

class SessionManager {
  constructor() {
    this.STORAGE_KEY = 'chatgpt_session';
    this.HISTORY_KEY = 'chat_history';
    this.accessToken = null;
    this.refreshToken = null;
    this.encryptionKey = null;
    this.user = null;
  }

  /**
   * 初始化会话管理器
   */
  async initialize() {
    await this.loadFromStorage();
    await this.validateSession();
  }

  /**
   * 从localStorage加载会话数据
   */
  async loadFromStorage() {
    try {
      const sessionData = localStorage.getItem(this.STORAGE_KEY);
      if (sessionData) {
        const parsed = JSON.parse(sessionData);
        
        // 验证数据完整性
        if (this.validateSessionData(parsed)) {
          this.accessToken = parsed.accessToken;
          this.refreshToken = parsed.refreshToken;
          this.encryptionKey = parsed.encryptionKey;
          this.user = parsed.user;
          
          // 设置请求拦截器，自动添加Authorization头
          this.setupRequestInterceptor();
          
          return true;
        }
      }
    } catch (error) {
      console.error('加载会话数据失败:', error);
      this.clearSession();
    }
    return false;
  }

  /**
   * 验证会话数据完整性
   */
  validateSessionData(data) {
    const requiredFields = ['accessToken', 'refreshToken', 'encryptionKey', 'user'];
    return requiredFields.every(field => data[field] !== null && data[field] !== undefined);
  }

  /**
   * 设置请求拦截器
   */
  setupRequestInterceptor() {
    // 使用Fetch API的拦截器
    const originalFetch = window.fetch;
    
    window.fetch = async (input, init = {}) => {
      const headers = new Headers(init.headers || {});
      
      // 为API请求添加Authorization头
      if (this.accessToken && input.toString().includes('/api/')) {
        headers.set('Authorization', `Bearer ${this.accessToken}`);
      }
      
      const config = {
        ...init,
        headers
      };
      
      let response = await originalFetch(input, config);
      
      // 处理401错误，尝试刷新令牌
      if (response.status === 401 && this.refreshToken) {
        const newToken = await this.refreshAccessToken();
        if (newToken) {
          // 更新Authorization头并重试请求
          headers.set('Authorization', `Bearer ${newToken}`);
          response = await originalFetch(input, { ...config, headers });
        }
      }
      
      return response;
    };
  }

  /**
   * 刷新访问令牌
   */
  async refreshAccessToken() {
    try {
      const response = await fetch('/api/session/refresh', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ refreshToken: this.refreshToken })
      });

      if (response.ok) {
        const data = await response.json();
        this.accessToken = data.accessToken;
        await this.saveToStorage();
        return data.accessToken;
      }
    } catch (error) {
      console.error('刷新令牌失败:', error);
    }
    
    // 刷新失败，清除会话
    this.clearSession();
    return null;
  }

  /**
   * 保存会话到localStorage
   */
  async saveToStorage() {
    const sessionData = {
      accessToken: this.accessToken,
      refreshToken: this.refreshToken,
      encryptionKey: this.encryptionKey,
      user: this.user,
      timestamp: Date.now()
    };
    
    localStorage.setItem(this.STORAGE_KEY, JSON.stringify(sessionData));
  }

  /**
   * 验证当前会话是否有效
   */
  async validateSession() {
    if (!this.accessToken) return false;
    
    try {
      const response = await fetch('/api/session/status', {
        headers: {
          'Authorization': `Bearer ${this.accessToken}`
        }
      });
      
      return response.ok;
    } catch (error) {
      return false;
    }
  }

  /**
   * 保存聊天记录
   */
  async saveChatHistory(history) {
    if (!this.encryptionKey) return;
    
    try {
      // 加密聊天记录
      const encrypted = this.encryptData(JSON.stringify(history));
      localStorage.setItem(this.HISTORY_KEY, JSON.stringify(encrypted));
      
      // 同步到服务器（可选）
      await this.syncToServer(history);
    } catch (error) {
      console.error('保存聊天记录失败:', error);
    }
  }

  /**
   * 加载聊天记录
   */
  async loadChatHistory() {
    try {
      const encryptedData = localStorage.getItem(this.HISTORY_KEY);
      if (encryptedData && this.encryptionKey) {
        const parsed = JSON.parse(encryptedData);
        const decrypted = this.decryptData(parsed);
        return JSON.parse(decrypted);
      }
    } catch (error) {
      console.error('加载聊天记录失败:', error);
    }
    return [];
  }

  /**
   * 加密数据（使用AES-256-CBC）
   */
  encryptData(text) {
    // 这里使用crypto-js库实现
    // 实际项目中需要引入：import CryptoJS from 'crypto-js';
    const CryptoJS = window.CryptoJS;
    const iv = CryptoJS.lib.WordArray.random(16);
    const encrypted = CryptoJS.AES.encrypt(text, CryptoJS.enc.Hex.parse(this.encryptionKey), {
      iv: iv,
      mode: CryptoJS.mode.CBC,
      padding: CryptoJS.pad.Pkcs7
    });
    
    return {
      iv: iv.toString(CryptoJS.enc.Hex),
      data: encrypted.toString()
    };
  }

  /**
   * 解密数据
   */
  decryptData(encrypted) {
    const CryptoJS = window.CryptoJS;
    const decrypted = CryptoJS.AES.decrypt(
      encrypted.data,
      CryptoJS.enc.Hex.parse(this.encryptionKey),
      {
        iv: CryptoJS.enc.Hex.parse(encrypted.iv),
        mode: CryptoJS.mode.CBC,
        padding: CryptoJS.pad.Pkcs7
      }
    );
    
    return decrypted.toString(CryptoJS.enc.Utf8);
  }

  /**
   * 同步聊天记录到服务器
   */
  async syncToServer(history) {
    try {
      await fetch('/api/chat/sync', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${this.accessToken}`
        },
        body: JSON.stringify({ history })
      });
    } catch (error) {
      console.error('同步到服务器失败:', error);
    }
  }

  /**
   * 清除会话
   */
  clearSession() {
    this.accessToken = null;
    this.refreshToken = null;
    this.encryptionKey = null;
    this.user = null;
    
    localStorage.removeItem(this.STORAGE_KEY);
    // 注意：不清除聊天记录，用户可能希望保留
  }
}

// 使用示例
const sessionManager = new SessionManager();

// 初始化会话
sessionManager.initialize().then(() => {
  if (sessionManager.user) {
    console.log('用户已登录:', sessionManager.user.username);
    
    // 加载聊天记录
    sessionManager.loadChatHistory().then(history => {
      console.log('加载的聊天记录:', history);
    });
  } else {
    console.log('用户未登录，显示登录界面');
  }
});

4. 性能与安全考量

4.1 会话数据加密方案

在混合存储方案中，数据安全至关重要。我采用了分层加密策略：

传输层加密：使用HTTPS确保数据传输安全。

存储层加密：

• 敏感数据（如聊天记录）使用AES-256-CBC加密后存储
• 加密密钥由服务端生成，通过加密通道传输给客户端
• 每个用户拥有独立的加密密钥

令牌安全：

• JWT使用HMAC-SHA256签名
• 设置合理的过期时间（访问令牌15分钟，刷新令牌7天）
• 刷新令牌存储在服务端，可主动撤销

4.2 令牌刷新机制设计

为了避免用户频繁重新登录，我设计了智能的令牌刷新机制：

class TokenRefresher {
  constructor(sessionManager) {
    this.sessionManager = sessionManager;
    this.refreshTimeout = null;
    this.isRefreshing = false;
    this.refreshQueue = [];
  }

  /**
   * 启动自动刷新
   */
  startAutoRefresh() {
    this.scheduleRefresh();
  }

  /**
   * 安排下一次刷新
   */
  scheduleRefresh() {
    if (this.refreshTimeout) {
      clearTimeout(this.refreshTimeout);
    }

    // 在令牌过期前5分钟刷新
    const tokenExpiry = this.getTokenExpiry();
    const refreshTime = tokenExpiry - 5 * 60 * 1000 - Date.now();
    
    if (refreshTime > 0) {
      this.refreshTimeout = setTimeout(() => {
        this.refreshToken();
      }, refreshTime);
    }
  }

  /**
   * 获取令牌过期时间
   */
  getTokenExpiry() {
    if (!this.sessionManager.accessToken) return 0;
    
    try {
      const payload = JSON.parse(atob(this.sessionManager.accessToken.split('.')[1]));
      return payload.exp * 1000;
    } catch (error) {
      return 0;
    }
  }

  /**
   * 刷新令牌
   */
  async refreshToken() {
    if (this.isRefreshing) {
      return new Promise((resolve) => {
        this.refreshQueue.push(resolve);
      });
    }

    this.isRefreshing = true;

    try {
      const newToken = await this.sessionManager.refreshAccessToken();
      
      // 处理等待中的请求
      this.refreshQueue.forEach(resolve => resolve(newToken));
      this.refreshQueue = [];
      
      // 重新安排下一次刷新
      this.scheduleRefresh();
      
      return newToken;
    } catch (error) {
      console.error('令牌刷新失败:', error);
      this.refreshQueue.forEach(resolve => resolve(null));
      this.refreshQueue = [];
      return null;
    } finally {
      this.isRefreshing = false;
    }
  }
}

5. 避坑指南

在实际开发中，我遇到了不少坑，这里分享一些常见问题的解决方案：

5.1 跨域会话同步问题

问题：当应用部署在多个子域名下时，localStorage无法共享。

解决方案：

1. 使用主域名Cookie存储会话标识
2. 通过postMessage API在不同窗口间同步状态
3. 使用共享的iframe作为存储中介

// 跨窗口会话同步
class CrossTabSync {
  constructor(channel = 'session_sync') {
    this.channel = channel;
    this.broadcastChannel = null;
    
    if (typeof BroadcastChannel !== 'undefined') {
      this.broadcastChannel = new BroadcastChannel(this.channel);
      this.setupListeners();
    }
  }

  setupListeners() {
    this.broadcastChannel.onmessage = (event) => {
      if (event.data.type === 'SESSION_UPDATE') {
        this.handleSessionUpdate(event.data.payload);
      }
    };
  }

  broadcastSessionUpdate(sessionData) {
    if (this.broadcastChannel) {
      this.broadcastChannel.postMessage({
        type: 'SESSION_UPDATE',
        payload: sessionData,
        timestamp: Date.now(),
        source: 'tab_' + Math.random().toString(36).substr(2, 9)
      });
    }
  }

  handleSessionUpdate(data) {
    // 更新本地存储
    localStorage.setItem('chatgpt_session', JSON.stringify(data));
    
    // 触发自定义事件，通知应用更新
    window.dispatchEvent(new CustomEvent('sessionUpdated', { detail: data }));
  }
}

5.2 移动端WebView存储限制

问题：iOS WebView在隐私模式下会限制localStorage使用。

解决方案：

1. 检测存储可用性并提供降级方案
2. 使用IndexedDB作为备用存储
3. 实现服务端备份机制

class StorageFallback {
  constructor() {
    this.storageType = this.detectStorageType();
  }

  detectStorageType() {
    try {
      localStorage.setItem('test', 'test');
      localStorage.removeItem('test');
      return 'localStorage';
    } catch (e) {
      // localStorage不可用，尝试IndexedDB
      if ('indexedDB' in window) {
        return 'indexedDB';
      }
      return 'memory';
    }
  }

  async setItem(key, value) {
    switch (this.storageType) {
      case 'localStorage':
        localStorage.setItem(key, JSON.stringify(value));
        break;
      case 'indexedDB':
        await this.saveToIndexedDB(key, value);
        break;
      case 'memory':
        this.memoryStorage[key] = value;
        break;
    }
  }

  async getItem(key) {
    switch (this.storageType) {
      case 'localStorage':
        const data = localStorage.getItem(key);
        return data ? JSON.parse(data) : null;
      case 'indexedDB':
        return await this.getFromIndexedDB(key);
      case 'memory':
        return this.memoryStorage[key] || null;
    }
  }

  async saveToIndexedDB(key, value) {
    return new Promise((resolve, reject) => {
      const request = indexedDB.open('ChatSessionDB', 1);
      
      request.onupgradeneeded = (event) => {
        const db = event.target.result;
        if (!db.objectStoreNames.contains('sessions')) {
          db.createObjectStore('sessions', { keyPath: 'key' });
        }
      };
      
      request.onsuccess = (event) => {
        const db = event.target.result;
        const transaction = db.transaction(['sessions'], 'readwrite');
        const store = transaction.objectStore('sessions');
        
        store.put({ key, value: JSON.stringify(value), timestamp: Date.now() });
        resolve();
      };
      
      request.onerror = reject;
    });
  }
}

5.3 会话数据清理策略

问题：长期积累的会话数据会占用大量存储空间。

解决方案：

1. 实现LRU（最近最少使用）清理策略
2. 设置数据过期时间
3. 提供手动清理选项

class SessionCleanup {
  constructor(maxSize = 50 * 1024 * 1024) { // 默认50MB
    this.maxSize = maxSize;
    this.checkInterval = 60 * 60 * 1000; // 每小时检查一次
  }

  startCleanupMonitor() {
    setInterval(() => this.cleanupIfNeeded(), this.checkInterval);
  }

  async cleanupIfNeeded() {
    const currentSize = await this.getStorageSize();
    
    if (currentSize > this.maxSize) {
      await this.cleanupOldSessions();
    }
  }

  async getStorageSize() {
    if (this.storageType === 'indexedDB') {
      return await this.getIndexedDBSize();
    }
    
    // 估算localStorage大小
    let total = 0;
    for (let i = 0; i < localStorage.length; i++) {
      const key = localStorage.key(i);
      const value = localStorage.getItem(key);
      total += key.length + value.length;
    }
    return total;
  }

  async cleanupOldSessions() {
    const sessions = await this.getAllSessions();
    
    // 按最后访问时间排序
    sessions.sort((a, b) => a.lastAccessed - b.lastAccessed);
    
    // 清理最旧的50%的会话
    const toRemove = Math.floor(sessions.length * 0.5);
    
    for (let i = 0; i < toRemove; i++) {
      await this.removeSession(sessions[i].id);
    }
  }
}

6. 实战效果与优化建议

经过上述方案的实施，我们的ChatGPT集成应用实现了：

1. 会话持久化：用户刷新页面或重新登录后，聊天记录完整保留
2. 多设备同步：通过服务端存储实现跨设备会话同步
3. 安全可靠：多层加密确保数据安全
4. 性能优化：智能缓存和懒加载提升响应速度

进一步优化建议：

1. 增量同步：只同步变化的聊天记录，减少数据传输量
2. 离线支持：使用Service Worker实现离线聊天
3. 压缩存储：对聊天记录进行压缩后再存储
4. 智能预加载：根据用户习惯预加载可能用到的会话

7. 示例代码与思考题

完整的实现代码可以在GitHub仓库查看：chatgpt-session-demo

思考题：如何实现分布式环境下的会话同步？

在微服务架构中，用户请求可能被路由到不同的服务实例。这就需要解决：

• 会话数据在不同实例间的一致性
• 分布式锁机制防止并发问题
• 会话迁移时的数据同步

一个可行的方案是使用Redis集群作为共享会话存储，配合一致性哈希算法确保同一用户的请求路由到正确的实例。

---

通过这个实战项目，我深刻体会到，一个稳定的AI对话应用不仅需要强大的模型能力，更需要完善的会话管理体系。从localStorage到JWT，从客户端加密到服务端同步，每一个环节都需要精心设计。

如果你对实时AI对话应用的完整技术链路感兴趣，想了解如何从零开始构建一个能听、能想、能说的AI伙伴，我推荐你体验一下从0打造个人豆包实时通话AI这个动手实验。我在实际操作中发现，它把ASR（语音识别）、LLM（大语言模型）、TTS（语音合成）这三个核心环节串成了一个完整的闭环，而且提供了清晰的代码示例和配置指南，对于想深入理解实时语音AI应用开发的同学来说，是个很不错的实践机会。