AI产品中的长期记忆和短期记忆是什么，你知道吗？

工边页字2026-03-17 10:08

同学们好哦

在 AI 应用开发（特别是大模型应用） 中，经常会提到两个概念：

  • 短期记忆（Short-term Memory）
  • 长期记忆（Long-term Memory）

可以把它理解为：
大模型像一个人聊天时的记忆系统

  • 短期记忆 → 当前对话临时记住的东西
  • 长期记忆 → 可以长期保存、随时取出来的东西

下面我们展开聊聊。

短期记忆（Short-term Memory）

短期记忆 = 当前对话上下文

本质就是：

Context Window（上下文窗口）

点击查看 Context Window的详细介绍

Context Window 也就是：

复制代码 
历史对话 + 当前输入 + 模型输出

例如：

复制代码 
用户：我叫小王
AI：好的小王

用户：我刚刚说我叫什么？
AI：小王

AI 能回答，是因为：

复制代码 
用户：我叫小王
AI：好的小王
用户：我刚刚说我叫什么？

这些 全部被放进 Context Window。

短期记忆的特点

特点 说明
临时 只在当前对话有效
有长度限制 Context Window 限制
超出会被截断 旧消息会被删除
不会长期保存 新对话就没了

例如：

GPT-4o

sql 复制代码 
Context Window ≈ 128k tokens

如果对话太长：

复制代码 
最早的聊天记录会被删掉

所以 AI 会 "失忆" 。

Context Window 超长处理

有小伙伴问：历史会话越来越多，context window超长之后需要截断，这个截断的过程是谁处理的，工程还是模型。

答案：工程这边处理

一般来说，context window 发送给模型之前，都会把最后需要发送的内容在工程内计算一下，然后结合目标模型最大可接受context window的大小来判断 ，需要裁剪掉多少内容。否则有些模型在context window超出的时候会直接报错。

我们以gpt-4o 为例子，它的context window 大小限制是128k ,分别以 javascript/python/java三个语言的真实代码看一下。

js案例

js 复制代码 
import OpenAI from "openai"
import { encoding_for_model } from "tiktoken"

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
})

// GPT-4o 的 context window
const MAX_CONTEXT = 128000

// 给输出预留 token
const MAX_OUTPUT = 4000

// tokenizer
const encoder = encoding_for_model("gpt-4o")

// 计算 token
function countTokens(messages) {
  let total = 0

  for (const msg of messages) {
    total += encoder.encode(msg.content).length
  }

  return total
}

// 裁剪历史
function trimMessages(messages) {
  while (countTokens(messages) > MAX_CONTEXT - MAX_OUTPUT) {
    // 删除最早的一条用户/assistant消息
    messages.splice(1, 1)
  }
  return messages
}

async function chat() {

  let messages = [
    { role: "system", content: "你是一个 helpful assistant" },
    { role: "user", content: "你好" },
    { role: "assistant", content: "你好！有什么可以帮你？" },
    { role: "user", content: "给我讲一下 JavaScript 的事件循环" }
  ]

  // 检测并裁剪 context
  messages = trimMessages(messages)

  const response = await client.chat.completions.create({
    model: "gpt-4o",
    messages,
    max_tokens: MAX_OUTPUT
  })

  console.log(response.choices[0].message.content)
}

chat()

python案例

python 复制代码 
from openai import OpenAI
import tiktoken

# 初始化客户端
client = OpenAI(api_key="YOUR_API_KEY_HERE")

# GPT-4o context window
MAX_CONTEXT = 128_000
MAX_OUTPUT = 4_000  # 给输出预留

# tokenizer
encoder = tiktoken.encoding_for_model("gpt-4o")

# 计算 token 数量
def count_tokens(messages):
    total = 0
    for msg in messages:
        total += len(encoder.encode(msg["content"]))
    return total

# 裁剪历史
def trim_messages(messages):
    while count_tokens(messages) > MAX_CONTEXT - MAX_OUTPUT:
        # 删除最早的用户/assistant消息（保留 system prompt）
        messages.pop(1)
    return messages

# 主聊天函数
def chat():
    messages = [
        {"role": "system", "content": "你是一个 helpful assistant"},
        {"role": "user", "content": "你好"},
        {"role": "assistant", "content": "你好！有什么可以帮你？"},
        {"role": "user", "content": "给我讲一下 JavaScript 的事件循环"}
    ]

    # 检测并裁剪 context
    messages = trim_messages(messages)

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        max_tokens=MAX_OUTPUT
    )

    print(response.choices[0].message["content"])

if __name__ == "__main__":
    chat()

java案例

java 复制代码 
<!-- Maven 依赖示例 -->
<dependencies>
    <!-- OpenAI 官方 Java SDK -->
    <dependency>
        <groupId>com.openai</groupId>
        <artifactId>openai</artifactId>
        <version>1.1.0</version>
    </dependency>

    <!-- tiktoken-java 用于 token 计算 -->
    <dependency>
        <groupId>com.github.acheong08</groupId>
        <artifactId>tiktoken-java</artifactId>
        <version>1.0.5</version>
    </dependency>
</dependencies>
java 复制代码 
from openai import OpenAI
import tiktoken

# 初始化客户端
client = OpenAI(api_key="YOUR_API_KEY_HERE")

# GPT-4o context window
MAX_CONTEXT = 128_000
MAX_OUTPUT = 4_000  # 给输出预留

# tokenizer
encoder = tiktoken.encoding_for_model("gpt-4o")

# 计算 token 数量
def count_tokens(messages):
    total = 0
    for msg in messages:
        total += len(encoder.encode(msg["content"]))
    return total

# 裁剪历史
def trim_messages(messages):
    while count_tokens(messages) > MAX_CONTEXT - MAX_OUTPUT:
        # 删除最早的用户/assistant消息（保留 system prompt）
        messages.pop(1)
    return messages

# 主聊天函数
def chat():
    messages = [
        {"role": "system", "content": "你是一个 helpful assistant"},
        {"role": "user", "content": "你好"},
        {"role": "assistant", "content": "你好！有什么可以帮你？"},
        {"role": "user", "content": "给我讲一下 JavaScript 的事件循环"}
    ]

    # 检测并裁剪 context
    messages = trim_messages(messages)

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        max_tokens=MAX_OUTPUT
    )

    print(response.choices[0].message["content"])

if __name__ == "__main__":
    chat()

长期记忆（Long-term Memory）

长期记忆 === AI 可以长期存储的数据

例如：

复制代码 
用户偏好
历史资料
知识库
用户画像

这些数据通常会存到：

复制代码 
数据库
向量数据库
知识库

当用户提问时：

复制代码 
用户提问
系统检索相关记忆
把记忆塞进 Prompt
再给模型

流程：

复制代码 
用户问题
   ↓
检索长期记忆
   ↓
拼进 Prompt
   ↓
发送给大模型
   ↓
生成回答

这其实就是：

RAG（Retrieval Augmented Generation）

举个完整例子

  • 用户第一次和 AI 聊天时，告诉 AI 自己的偏好：

    • "我喜欢美式咖啡"
    • "我在学 JavaScript"

  • 系统把这些信息存入 长期记忆（向量数据库）

  • 下次用户提问时（此时可能已经切换了session）：

    • 系统先 检索相关长期记忆 ，这一步属于向量搜索的范围(Embedding)，点击查看详细解析
    • 把相关内容加入 Context Window
    • 发送给模型

还是以js/python/java为代码实例，大家参考一下

js

js 复制代码 
import OpenAI from "openai";
import { encoding_for_model } from "tiktoken";
import { PineconeClient } from "@pinecone-database/pinecone";

// 初始化 GPT 客户端
const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// 初始化向量数据库（长期记忆）
const pinecone = new PineconeClient();
await pinecone.init({ apiKey: process.env.PINECONE_API_KEY, environment: "us-west1-gcp" });
const index = pinecone.Index("user-memory");

// GPT-4o context window
const MAX_CONTEXT = 128000;
const MAX_OUTPUT = 4000;
const encoder = encoding_for_model("gpt-4o");

// 计算 token 数量
function countTokens(messages) {
  let total = 0;
  for (const msg of messages) {
    total += encoder.encode(msg.content).length;
  }
  return total;
}

// 裁剪短期记忆
function trimMessages(messages) {
  while (countTokens(messages) > MAX_CONTEXT - MAX_OUTPUT) {
    messages.splice(1, 1); // 删除最旧消息
  }
  return messages;
}

// 把长期记忆存入向量数据库
async function storeLongTermMemory(userId, text) {
  // 1. 获取 embedding
  const embeddingResponse = await client.embeddings.create({
    model: "text-embedding-3-large",
    input: text
  });
  const vector = embeddingResponse.data[0].embedding;

  // 2. 存入向量数据库
  await index.upsert({
    upsertRequest: {
      vectors: [
        {
          id: `${userId}-${Date.now()}`,
          values: vector,
          metadata: { text }
        }
      ]
    }
  });
}

// 查询长期记忆（RAG）
async function retrieveLongTermMemory(userId, query, topK = 5) {
  const embeddingResponse = await client.embeddings.create({
    model: "text-embedding-3-large",
    input: query
  });
  const vector = embeddingResponse.data[0].embedding;

  const searchResponse = await index.query({
    queryRequest: {
      vector,
      topK,
      includeMetadata: true,
      filter: { userId }
    }
  });

  return searchResponse.matches.map(m => m.metadata.text);
}

// 主对话流程
async function chat(userId, userMessage) {
  // 1. 检索相关长期记忆
  const longTermMemory = await retrieveLongTermMemory(userId, userMessage);

  // 2. 构建短期记忆
  let messages = [
    { role: "system", content: "你是一个 helpful assistant" }
  ];

  // 把长期记忆加入短期记忆
  if (longTermMemory.length > 0) {
    messages.push({
      role: "system",
      content: `用户的长期记忆信息:\n${longTermMemory.join("\n")}`
    });
  }

  // 当前用户消息
  messages.push({ role: "user", content: userMessage });

  // 3. 裁剪 context window
  messages = trimMessages(messages);

  // 4. 生成回答
  const response = await client.chat.completions.create({
    model: "gpt-4o",
    messages,
    max_tokens: MAX_OUTPUT
  });

  const answer = response.choices[0].message.content;
  console.log("AI:", answer);

  // 5. 存储新的长期记忆（可选）
  await storeLongTermMemory(userId, userMessage);
}

// --- 使用示例 ---
const userId = "user123";

// 第一次对话，存长期记忆
await storeLongTermMemory(userId, "我喜欢美式咖啡");
await storeLongTermMemory(userId, "我正在学习 JavaScript");

// 用户发问
await chat(userId, "给我推荐一款咖啡？");
await chat(userId, "帮我讲一下 JavaScript 的事件循环");

python

python 复制代码 
# pip install openai tiktoken pinecone-client
from openai import OpenAI
import tiktoken
import pinecone
import os

# 初始化 OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# 初始化 Pinecone
pinecone.init(api_key=os.getenv("PINECONE_API_KEY"), environment="us-west1-gcp")
index = pinecone.Index("user-memory")

# GPT-4o context window
MAX_CONTEXT = 128_000
MAX_OUTPUT = 4_000
encoder = tiktoken.encoding_for_model("gpt-4o")

# 计算 token
def count_tokens(messages):
    total = 0
    for msg in messages:
        total += len(encoder.encode(msg["content"]))
    return total

# 裁剪短期记忆
def trim_messages(messages):
    while count_tokens(messages) > MAX_CONTEXT - MAX_OUTPUT:
        messages.pop(1)  # 删除最早消息
    return messages

# 存储长期记忆
def store_long_term_memory(user_id, text):
    embedding_response = client.embeddings.create(
        model="text-embedding-3-large",
        input=text
    )
    vector = embedding_response.data[0].embedding
    index.upsert(
        vectors=[{
            "id": f"{user_id}-{int(os.times().system)}",
            "values": vector,
            "metadata": {"text": text, "userId": user_id}
        }]
    )

# 检索长期记忆
def retrieve_long_term_memory(user_id, query, top_k=5):
    embedding_response = client.embeddings.create(
        model="text-embedding-3-large",
        input=query
    )
    vector = embedding_response.data[0].embedding
    search_response = index.query(
        vector=vector,
        top_k=top_k,
        include_metadata=True,
        filter={"userId": user_id}
    )
    return [match['metadata']['text'] for match in search_response['matches']]

# 主聊天流程
def chat(user_id, user_message):
    long_term_memory = retrieve_long_term_memory(user_id, user_message)
    messages = [{"role": "system", "content": "你是一个 helpful assistant"}]

    if long_term_memory:
        messages.append({
            "role": "system",
            "content": f"用户的长期记忆信息:\n{chr(10).join(long_term_memory)}"
        })

    messages.append({"role": "user", "content": user_message})
    messages = trim_messages(messages)

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        max_tokens=MAX_OUTPUT
    )
    answer = response.choices[0].message["content"]
    print("AI:", answer)

    # 可选：把新信息存入长期记忆
    store_long_term_memory(user_id, user_message)


# --- 使用示例 ---
user_id = "user123"
store_long_term_memory(user_id, "我喜欢美式咖啡")
store_long_term_memory(user_id, "我正在学习 JavaScript")

chat(user_id, "给我推荐一款咖啡？")
chat(user_id, "帮我讲一下 JavaScript 的事件循环")

java

java 复制代码 
import com.theokanning.openai.OpenAiService;
import com.theokanning.openai.completion.chat.*;
import com.github.acheong08.tiktoken.Tiktoken;
import com.github.acheong08.tiktoken.Encoding;
import com.pinecone.PineconeClient; // 假设你用 Pinecone Java SDK

import java.util.ArrayList;
import java.util.List;

public class LongTermMemoryChat {

    private static final int MAX_CONTEXT = 128_000;
    private static final int MAX_OUTPUT = 4_000;

    public static void main(String[] args) {
        OpenAiService client = new OpenAiService(System.getenv("OPENAI_API_KEY"));

        // 初始化 tokenizer
        Encoding encoder = Tiktoken.encodingForModel("gpt-4o");

        // 初始化 Pinecone (长期记忆)
        PineconeClient pinecone = new PineconeClient(System.getenv("PINECONE_API_KEY"));
        var index = pinecone.Index("user-memory");

        String userId = "user123";

        // 存储长期记忆
        storeLongTermMemory(client, index, userId, "我喜欢美式咖啡");
        storeLongTermMemory(client, index, userId, "我正在学习 JavaScript");

        // 对话
        chat(client, encoder, index, userId, "给我推荐一款咖啡？");
        chat(client, encoder, index, userId, "帮我讲一下 JavaScript 的事件循环");
    }

    // 存储长期记忆
    public static void storeLongTermMemory(OpenAiService client, Object index, String userId, String text) {
        var embeddingResponse = client.createEmbeddings(
                OpenAiService.EmbeddingsRequest.builder()
                        .model("text-embedding-3-large")
                        .input(text)
                        .build()
        );
        var vector = embeddingResponse.getData().get(0).getEmbedding();
        // upsert 向量到 index
        // index.upsert(...)   // 这里具体调用看你使用的 SDK
    }

    // 检索长期记忆
    public static List<String> retrieveLongTermMemory(OpenAiService client, Object index, String userId, String query, int topK) {
        var embeddingResponse = client.createEmbeddings(
                OpenAiService.EmbeddingsRequest.builder()
                        .model("text-embedding-3-large")
                        .input(query)
                        .build()
        );
        var vector = embeddingResponse.getData().get(0).getEmbedding();
        // 搜索向量库
        List<String> results = new ArrayList<>();
        // 假设搜索返回 metadata.text
        // results.add(...);
        return results;
    }

    // 裁剪短期记忆
    public static List<ChatMessage> trimMessages(List<ChatMessage> messages, Encoding encoder) {
        while (countTokens(messages, encoder) > MAX_CONTEXT - MAX_OUTPUT) {
            messages.remove(1);
        }
        return messages;
    }

    public static int countTokens(List<ChatMessage> messages, Encoding encoder) {
        int total = 0;
        for (ChatMessage msg : messages) {
            total += encoder.encode(msg.getContent()).size();
        }
        return total;
    }

    // 主聊天流程
    public static void chat(OpenAiService client, Encoding encoder, Object index, String userId, String userMessage) {
        List<String> longTermMemory = retrieveLongTermMemory(client, index, userId, userMessage, 5);

        List<ChatMessage> messages = new ArrayList<>();
        messages.add(new ChatMessage("system", "你是一个 helpful assistant"));

        if (!longTermMemory.isEmpty()) {
            messages.add(new ChatMessage("system", "用户的长期记忆信息:\n" + String.join("\n", longTermMemory)));
        }

        messages.add(new ChatMessage("user", userMessage));
        messages = trimMessages(messages, encoder);

        ChatCompletionRequest request = ChatCompletionRequest.builder()
                .model("gpt-4o")
                .messages(messages)
                .maxTokens(MAX_OUTPUT)
                .build();

        ChatCompletionResult result = client.createChatCompletion(request);
        System.out.println("AI: " + result.getChoices().get(0).getMessage().getContent());

        // 可选：把用户新消息存入长期记忆
        storeLongTermMemory(client, index, userId, userMessage);
    }
}

AI系统的完整记忆架构

真实 AI 产品一般是这样设计：

markdown 复制代码 
                 用户输入
                    │
                    ▼
              ┌───────────┐
              │ 短期记忆  │
              │ Context   │
              └───────────┘
                    │
                    ▼
              ┌───────────┐
              │ 长期记忆  │
              │ Vector DB │
              └───────────┘
                    │
                    ▼
                  Prompt
                    │
                    ▼
                  大模型
                    │
                    ▼
                   回复

短期记忆 vs 长期记忆（核心区别）

短期记忆 长期记忆
本质 Context Window 外部存储
生命周期 当前对话 永久
存储位置 Prompt DB / Vector DB
大小 有限制 几乎无限
用途 上下文理解 知识/用户记忆

总结来说：

短期记忆是模型的"脑子"，长期记忆是模型的"外挂硬盘"。

AI工程里的经典组合

真实 AI 应用基本是这三层：

diff 复制代码 
短期记忆
+ 长期记忆
+ 工具调用

也就是：

复制代码 
Conversation Memory
RAG Memory
Tool Memory

很多 AI Agent 架构都是这样。

为什么大模型一定要有长期记忆

大模型本身是 无状态的

  • 大模型 API（如 GPT-4o、Claude）本身不会存储任何用户对话。
  • 每次请求都是 全新的计算 ，短期记忆只能通过 上下文传递。
  • 如果没有长期记忆，模型就"每次都是新鲜人"，无法延续跨会话的知识。

举例：

  • 今天用户说：我喜欢美式咖啡
  • 明天用户问：给我推荐咖啡
  • 如果没有长期记忆，模型不知道用户偏好，只能随机推荐

Context Window 有限制

  • GPT-4o context window ≈ 128k tokens
  • 对话过长或长期使用时，旧消息会被裁剪
  • 这导致 短期记忆只能保留最近几轮对话
  • 长期记忆才能保存核心信息，避免重要数据被丢掉

支撑个性化和用户体验

长期记忆让模型能做到：

  • 记住用户偏好
  • 记住历史任务和问题
  • 提供连续性和个性化回答

例如：

  • "小王喜欢喝美式咖啡" → 明天直接推荐冷萃
  • "用户之前问过 JavaScript 事件循环" → 下次能直接接着讲

支持 RAG（Retrieval-Augmented Generation）

  • 大模型知识有限（截止训练时间）
  • 用户提供的长期数据不能全部塞进 Context Window
  • 解决方案：把长期知识 存储到向量数据库或文档库
  • 查询时再检索，结合当前对话生成回答

流程：

复制代码 
用户问题 → 检索长期记忆 → 拼入 Prompt → 模型生成回答

这就是现代大模型系统必须做长期记忆的根本原因。

工程成本角度

  • 如果只靠短期记忆：

    • 大量信息会被丢掉
    • 每次都要重复提供上下文
    • 用户体验差

  • 长期记忆 + RAG：

    • 数据可以压缩、摘要、索引
    • 只检索相关信息
    • 节省 token 成本和计算资源

总结

  1. 短期记忆可以理解为让模型记住当前session内的历史会话
  2. 长期记忆可以理解为让模型除了当前session外，其他session里的历史对话
  3. 一般的ai产品应用会同时具备长期记忆和短期记忆
  4. 短期记忆的实现方式只需要把当前session的历史记录摘要汇总到prompt里即可
  5. 长期记忆需要通过RAG功能把相关内容向量匹配出来再汇总到prompt

最后

如果对你有用的话

相关推荐
Westward-sun.2 小时前
OpenCV 实战：花朵轮廓提取与近似轮廓绘制
人工智能·opencv·计算机视觉
智算菩萨2 小时前
从“流畅“到“动人“：用 ChatGPT 5.4 写出感情真挚的英语散文全攻略
人工智能·gpt·ai·chatgpt·ai写作
HelloReader2 小时前
Flutter 页面导航Navigator.push 与自适应导航模式（十四）
前端
毕设源码-钟学长2 小时前
【开题答辩全过程】以 基于SpringBoot的健康系统为例，包含答辩的问题和答案
java·spring boot·后端
小凡同志2 小时前
那个复制粘贴了二十次 loading 的下午
前端·vue.js
HelloReader2 小时前
Flutter 底层原理揭秘框架如何工作（十五）
前端
南篱2 小时前
前端必看：一口气搞懂跨域是什么、为什么、怎么解决
前端·javascript·面试
集芯微电科技有限公司2 小时前
适用于GaN PD快充65W/33W超高频驱动器
人工智能·单片机·嵌入式硬件·深度学习·神经网络·机器学习·生成对抗网络
qq_406176142 小时前
Vue 插槽与组件传参：从入门到精通
前端·javascript·vue.js
热门推荐
01GitHub 镜像站点02Qwen3.5 开源全解析：从 0.8B 到 397B，代际升级 + 全场景选型指南03OpenClaw 使用和管理 MCP 完全指南04OpenClaw Control UI安全上下文访问配置05UV安装并设置国内源06本地部署 OpenClaw + DeepSeek-R1 完全指南07OpenClaw macOS 完整安装与本地模型配置教程（实战版）08Openclow安装保姆级教程09Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services10让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南