【Letta】让大模型拥有"操作系统级"记忆能力深度解析

发表于 更新于 分类于

Letta深度解析：让大模型拥有”操作系统级”记忆能力

前言

你有没有遇到过这种情况？

你跟一个AI助手聊了两个小时的项目背景，告诉它你的需求、偏好、约束条件。结果第三天再打开，它完全不记得你了——就像一个每次醒来都失忆的人。

这不仅是AI的尴尬，更是当前Agent架构的根本缺陷：上下文窗口再大，也装不下人类一辈子的经历。

Letta（前身是著名的MemGPT项目）正是为解决这一问题而生。它的核心思想极其优雅：让大模型像操作系统一样管理记忆——有快慢内存之分，有分页机制，有中断处理。

本文将深入解析Letta的分层记忆架构、Compaction压缩机制、Multi-Agent协作模式，以及它与其他主流记忆系统的本质差异。

mindmap
  root((Letta核心创新))
    核心问题
      LLM上下文窗口有限
      无法记住长期交互
      Agent缺乏连续性
    解决思路
      OS式分层记忆
      虚拟上下文管理
      快慢内存调度
    关键机制
      Core Memory
      Archival Memory
      Compaction压缩
      分页检索

一、项目概览

1.1 什么是Letta

Letta是一个有状态（Stateful）的AI Agent平台，专注于解决LLM的”记忆问题”。它最初以MemGPT的名字发表在2023年10月，论文标题极具野心：“Towards LLMs as Operating Systems”——让大模型成为操作系统。

flowchart TB
    subgraph 问题["❌ 传统LLM的困境"]
        P1["上下文窗口有限<br/>GPT-4o: 128K tokens"]
        P2["长对话记忆丢失<br/>超过窗口全部遗忘"]
        P3["无法做深度分析<br/>超出窗口的文档处理不了"]
    end
    
    subgraph Letta方案["✅ Letta的解法"]
        S1["分层记忆管理<br/>像OS一样分快慢内存"]
        S2["虚拟上下文管理<br/>在有限窗口内呈现无限上下文"]
        S3["Compaction压缩<br/>自动整理和遗忘不重要记忆"]
    end
    
    P1 & P2 & P3 --> S1 & S2 & S3
    
    style 问题 fill:#FFA07A,stroke:#FF6347
    style Letta方案 fill:#98FB98,stroke:#228B22

1.2 核心数据

指标数据
GitHub Stars20,000+
前身MemGPT（2023年10月论文）
团队Letta AI
最新版本v0.4+
编程语言Python / TypeScript
支持模型OpenAI / Anthropic / Gemini / DeepSeek 全覆盖

1.3 核心特性一览

flowchart LR
    subgraph 特性["✨ Letta核心能力"]
        F1["🧠 分层记忆<br/>Core + Archival双层"]
        F2["📦 Compaction<br/>自动压缩整理"]
        F3["🔍 向量检索<br/>Archival语义搜索"]
        F4["🤖 多Agent协作<br/>团队模式"]
        F5["🔌 MCP工具<br/>生态集成"]
        F6["🎯 状态持久化<br/>跨会话记忆"]
    end
    
    style 特性 fill:#87CEEB,stroke:#4169E1

二、核心架构：OS风格的记忆系统

2.1 传统OS的分层内存 vs Letta的分层记忆

这是Letta最核心的洞察——把LLM比作CPU，把记忆比作内存/硬盘：

flowchart TB
    subgraph 传统OS["💻 操作系统"]
        OS_CPU["CPU寄存器<br/>极快/极小/常驻"]
        OS_L1["L1/L2 Cache<br/>快/小"]
        OS_RAM["RAM 主内存<br/>中速/中量"]
        OS_DISK["磁盘<br/>慢/大/持久"]
    end
    
    subgraph OS内存调度["⚙️ OS内存管理"]
       调度["分页调度<br/>换入换出<br/>按需加载"]
    end
    
    OS_CPU --> 调度
    OS_L1 --> 调度
    OS_RAM --> 调度
    OS_DISK --> 调度
    
    subgraph Letta["🤖 Letta Agent"]
        L_CORE["Core Memory<br/>快速/活跃/当前上下文"]
        L_ARCH["Archival Memory<br/>慢速/归档/向量存储"]
    end
    
    L_CORE --> L_ARCH
    
    style 传统OS fill:#DDA0DD,stroke:#9370DB
    style Letta fill:#98FB98,stroke:#228B22
    
    note["OS: CPU看到的是虚拟地址空间<br/>Letta: LLM看到的是虚拟上下文"]

2.2 Letta的分层记忆架构

flowchart TB
    subgraph 当前上下文["📋 当前上下文（LLM直接可见）"]
        CTX["对话历史<br/>当前会话"]
        CORE["Core Memory<br/>核心记忆片段"]
        SYSTEM["System Prompt<br/>角色设定"]
    end
    
    subgraph 归档存储["📦 Archival Memory（LLM不可直接访问）"]
        ARCH["长期记忆<br/>历史对话/知识"]
        FACTS["事实性知识<br/>用户偏好/经历"]
        DOCS["文档摘要<br/>处理过的文档"]
    end
    
    subgraph 管理机制["🔧 记忆管理"]
        RETRIEVE["检索机制<br/>当需要时召回"]
        COMPACT["Compaction<br/>压缩不重要记忆"]
        PAGE["分页调度<br/>按需加载"]
    end
    
    RETRIEVE --> ARCH
    COMPACT --> ARCH
    PAGE --> ARCH
    
    CTX & CORE & SYSTEM --> 当前上下文
    
    style 当前上下文 fill:#98FB98,stroke:#228B22
    style 归档存储 fill:#87CEEB,stroke:#4169E1
    style 管理机制 fill:#DDA0DD,stroke:#9370DB

2.3 记忆块（Memory Blocks）

Letta用Memory Blocks作为记忆的基本单元：

flowchart TB
    subgraph MemoryBlock类型["📦 Memory Block 类型"]
        HUMAN["human block<br/>用户信息<br/>姓名/偏好/历史"]
        PERSONA["persona block<br/>Agent人设<br/>性格/能力/目标"]
        CUSTOM["custom blocks<br/>自定义记忆<br/>任意结构化信息"]
    end
    
    subgraph Block结构["🔧 Block结构"]
        B1["label: 标识名称"]
        B2["value: 记忆内容"]
        B3["timestamp: 时间戳"]
    end
    
    HUMAN & PERSONA & CUSTOM --> Block结构
    
    style MemoryBlock类型 fill:#DDA0DD,stroke:#9370DB
    style Block结构 fill:#87CEEB,stroke:#4169E1

Memory Block示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
# human block - 存储用户信息
{
    "label": "human",
    "value": "Name: Timber. Status: dog. 
              Occupation: building Letta"
}

# persona block - 存储Agent人设
{
    "label": "persona", 
    "value": "I am a self-improving 
              superintelligence."
}

三、核心机制深度解析

3.1 虚拟上下文管理（Virtual Context Management）

这是Letta/MemGPT的核心创新。它的原理是：

1
2
3
4
5
6
传统方案：          Letta方案：
┌─────────────┐    ┌──────────────────────┐
│  有限上下文   │    │  虚拟无限上下文        │
│  128K tokens │    │  LLM以为自己能看到全部  │
│              │    │  实际被分页管理        │
└─────────────┘    └──────────────────────┘
flowchart TB
    subgraph 虚拟上下文["🎭 虚拟上下文（LLM视角）"]
        VIRT["LLM认为的完整上下文<br/>包含所有历史记忆<br/>看起来无限大"]
    end
    
    subgraph 实际分页["💾 实际分页管理"]
        PAGE1["Page 1: Core Memory<br/>核心记忆（常驻）"]
        PAGE2["Page 2: 当前对话<br/>最新交互"]
        PAGE3["Page 3: 归档检索<br/>从Archival召回"]
        PAGE4["Page N: 历史归档<br/>压缩存储"]
    end
    
    subgraph 调度器["⚙️ 上下文调度器"]
        TRIGGER["触发条件检测"]
        RECALL["检索召回"]
        EVICT["换出(Evict)"]
        COMPACT["压缩整理"]
    end
    
    VIRT --> 实际分页
    实际分页 --> 调度器
    调度器 --> VIRT
    
    style 虚拟上下文 fill:#98FB98,stroke:#228B22
    style 实际分页 fill:#87CEEB,stroke:#4169E1
    style 调度器 fill:#DDA0DD,stroke:#9370DB

3.2 Compaction（记忆压缩）

当Core Memory快要满的时候，Letta会自动触发Compaction：

flowchart TB
    subgraph Compaction触发["⚡ 触发条件"]
        C1["Core Memory使用率>80%"]
        C2["上下文窗口接近上限"]
        C3["用户明确要求整理"]
    end
    
    subgraph Compaction过程["🔄 压缩过程"]
        P1["读取Archival Memory"]
        P2["LLM分析记忆重要性"]
        P3["压缩低价值记忆片段"]
        P4["更新Core + Archival"]
    end
    
    subgraph 结果["✅ 压缩结果"]
        R1["Core Memory释放空间"]
        R2["关键信息保留在Core"]
        R3["次要信息归档到Archival"]
    end
    
    C1 & C2 & C3 --> Compaction过程
    Compaction过程 --> R1 & R2 & R3
    
    style Compaction触发 fill:#FFA07A,stroke:#FF6347
    style Compaction过程 fill:#FFE4B5,stroke:#FFA500
    style 结果 fill:#98FB98,stroke:#228B22

Compaction的判断逻辑（伪代码）：

1
2
3
4
5
6
7
8
9
10
11
12
function should_compact(core_memory, archival_memory):
    # 判断是否需要压缩
    if core_memory.usage_ratio > 0.8:
        # 分析哪些记忆可以归档
        for block in core_memory.blocks:
            importance = llm.judge_importance(block)
            if importance < threshold:
                archival_memory.store(block)  # 移入归档
                core_memory.remove(block)
    
    # 压缩后的核心记忆仍然保留最重要的事实
    return core_memory.space_freed > required_space

3.3 检索与召回机制

当Agent需要某个记忆但它不在Core Memory中时，触发检索：

sequenceDiagram
    participant Agent as LLM Agent
    participant Core as Core Memory
    participant Retriever as 检索器
    participant Archival as Archival Memory
    participant LLM as 大语言模型
    
    Note over Agent,Core: 场景：Agent需要某段历史记忆
    Agent->>LLM: 需要查找"上次讨论的架构设计"
    LLM->>Retriever: 发起检索请求
    Retriever->>Archival: 向量相似度搜索
    Archival-->>Retriever: 返回Top-K相关记忆
    Retriever-->>Agent: 召回的记忆片段
    Agent->>Core: 将召回记忆加入当前上下文
    Note over Core: 如果空间不足，触发换出机制

3.4 自我反思（Self-Reflection）

Letta的一个关键能力是让Agent能够主动反思和更新记忆：

flowchart TB
    subgraph 反思触发["🤔 什么时候反思"]
        T1["用户对话结束后"]
        T2["记忆使用率过高时"]
        T3["Agent主动请求"]
    end
    
    subgraph 反思过程["🔄 反思过程"]
        F1["读取当前Core Memory"]
        F2["LLM分析：哪些重要？哪些可以归档？"]
        F3["更新persona block（自我认知）"]
        F4["更新human block（用户理解）"]
        F5["归档次要记忆到Archival"]
    end
    
    subgraph 反思结果["📝 反思输出"]
        O1["更精确的自我认知"]
        O2["更理解用户的偏好"]
        O3["更高效的记忆结构"]
    end
    
    T1 & T2 & T3 --> 反思过程
    反思过程 --> O1 & O2 & O3
    
    style 反思触发 fill:#DDA0DD,stroke:#9370DB
    style 反思过程 fill:#87CEEB,stroke:#4169E1
    style 反思结果 fill:#98FB98,stroke:#228B22

四、多Agent协作模式

Letta支持多种多Agent协作模式，适用于不同场景：

flowchart TB
    subgraph 团队模式["👥 Multi-Agent团队模式"]
        M1["Supervisor-Worker<br/>主管+执行者"]
        M2["Round-Robin<br/>轮询协作"]
        M3["Parallel Execution<br/>并行执行"]
        M4["Producer-Reviewer<br/>生产-审查"]
        M5["Hierarchical Teams<br/>层级团队"]
    end
    
    style 团队模式 fill:#DDA0DD,stroke:#9370DB

4.1 Supervisor-Worker模式

flowchart TB
    subgraph Supervisor["👔 Supervisor Agent"]
        S1["理解用户整体需求"]
        S2["分解为子任务"]
        S3["分配给合适的Worker"]
        S4["汇总Worker结果"]
    end
    
    subgraph Workers["👷 Worker Agents"]
        W1["Worker-1<br/>代码编写"]
        W2["Worker-2<br/>文档撰写"]
        W3["Worker-3<br/>测试验证"]
    end
    
    subgraph Shared["🔗 Shared Memory"]
        SM["共享记忆<br/>所有Agent可访问"]
    end
    
    S1 --> S2 --> S3
    S3 --> W1 & W2 & W3
    W1 & W2 & W3 --> S4
    W1 & W2 & W3 -.-> SM
    SM -.-> S4
    
    style Supervisor fill:#87CEEB,stroke:#4169E1
    style Workers fill:#98FB98,stroke:#228B22
    style Shared fill:#DDA0DD,stroke:#9370DB

4.2 Shared Memory（共享记忆）

Letta支持多Agent共享记忆，这是Multi-Agent协作的关键：

flowchart TB
    subgraph Agent1["🤖 Agent-1 (Writer)"]
        A1_CORE["Core: 写作规范记忆"]
        A1_SHARED["Shared: 项目背景"]
    end
    
    subgraph Agent2["🤖 Agent-2 (Reviewer)"]
        A2_CORE["Core: 评审标准记忆"]
        A2_SHARED["Shared: 项目背景"]
    end
    
    subgraph 共享区["🔗 Shared Memory Zone"]
        SHARED["项目规范<br/>代码风格<br/>架构决策"]
    end
    
    A1_SHARED -.-> SHARED
    A2_SHARED -.-> SHARED
    
    style Agent1 fill:#87CEEB,stroke:#4169E1
    style Agent2 fill:#98FB98,stroke:#228B22
    style 共享区 fill:#FFE4B5,stroke:#FFA500

五、对比分析：Letta vs 其他记忆方案

5.1 记忆机制全景对比

flowchart LR
    subgraph 方案["记忆方案"]
        LTT["Letta<br/>分层记忆+OS调度"]
        RAG["传统RAG<br/>向量检索"]
        COT["CoT提示<br/>上下文链"]
        MEM["简单记忆<br/>Summary摘要"]
    end
    
    LTT --> ADV["优势"]
    LTT --> LIM["局限"]
    
    ADV --> A1["✅ 主动管理记忆"]
    ADV --> A2["✅ 自动压缩整理"]
    ADV --> A3["✅ 长期记忆持久化"]
    ADV --> A4["✅ 多Agent共享"]
    
    LIM --> L1["⚠️ 架构复杂度高"]
    LIM --> L2["⚠️ LLM本身能力依赖"]
    
    style LTT fill:#98FB98,stroke:#228B22

5.2 详细对比表

维度Letta传统RAG简单Summary
记忆管理分层+自动压缩静态向量库手动总结
检索方式主动召回+向量纯向量相似度无检索
记忆更新Agent主动反思更新外部系统更新人工更新
多Agent支持✅ 原生支持❌ 不支持❌ 不支持
上下文利用智能分页全部加载全量摘要
实现复杂度高中低
适用场景复杂Agent知识库问答简单助手

5.3 核心差异解析

Letta vs 传统RAG的本质区别：

1
2
3
4
5
6
7
8
9
10
传统RAG：          Letta：
┌─────────────┐    ┌──────────────────────┐
│ 用户问问题   │    │ Agent持续运行        │
│ → 检索向量库 │    │ → 主动管理记忆层级   │
│ → 拼进上下文 │    │ → 上下文窗口智能调度 │
│ → 生成回答   │    │ → 回答时动态召回     │
└─────────────┘    └──────────────────────┘

RAG是被动问答
Letta是主动记忆管理

5.4 Letta vs AutoGen/MCP

维度LettaAutoGenMCP
定位Agent记忆平台Multi-Agent对话框架Tool调用协议
核心能力长期记忆管理Agent协作编排工具标准化
记忆✅ 内置分层记忆❌ 无内置记忆❌ 无记忆
Multi-Agent✅ 团队+共享记忆✅ 对话协作❌ 协议层面
适用场景个人助手/客服复杂工作流工具集成

六、快速上手

6.1 安装Letta

1
2
3
4
5
6
7
8
9
# 安装Letta Server（Docker方式）
docker pull letta/letta:latest
docker run -p 8283:8283 letta/letta

# 或者使用pip安装Python SDK
pip install letta-client

# 安装CLI工具
npm install -g @letta-ai/letta-code

6.2 创建第一个有记忆的Agent

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
from letta_client import Letta
import os

client = Letta(api_key=os.getenv("LETTA_API_KEY"))

# 创建带记忆的Agent
agent = client.agents.create(
    model="anthropic/claude-opus-4-6",
    
    # Core Memory - Agent的人设和角色
    memory_blocks=[
        {
            "label": "persona",
            "value": """你是一个专业的Python导师。
            你擅长用简单的方式解释复杂的概念。
            你会主动了解学生的学习进度和困难点。
            """
        },
        {
            "label": "human", 
            "value": """学生姓名: 小明
            背景: 零基础学习编程
            进度: 已学完基础语法
            偏好: 喜欢动手实践
            """
        }
    ],
    
    # 给Agent配备的工具
    tools=["web_search", "fetch_webpage", "python_executor"]
)

print(f"Agent创建成功: {agent.id}")

# 开始对话 - Agent会记住之前的对话内容
response = client.agents.messages.create(
    agent_id=agent.id,
    input="我上周学的函数，今天忘了怎么定义了"
)

# Agent能够主动检索记忆，知道用户的背景和学习进度
print(response.messages[-1].content)

6.3 使用Compaction和检索

1
2
3
4
5
6
7
8
9
10
11
12
13
# 手动触发记忆整理
client.agents.compact(agent_id=agent.id)

# 检索历史记忆
results = client.agents.memory.retrieve(
    agent_id=agent.id,
    query="小明学习Python的进度",
    top_k=5
)

# 查看Agent当前的记忆状态
memory_state = client.agents.memory.get(agent_id=agent.id)
print(f"Core Memory使用率: {memory_state.core_usage}%")

6.4 多Agent协作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 创建一个团队
team = client.teams.create(name="CodeReviewTeam")

# 创建不同角色的Agent
writer = client.agents.create(
    name="Writer",
    memory_blocks=[{"label": "persona", "value": "代码编写专家"}],
    tools=["code_write", "file_edit"]
)

reviewer = client.agents.create(
    name="Reviewer", 
    memory_blocks=[{"label": "persona", "value": "代码审查专家"}],
    tools=["code_review", "code_fix"]
)

# 给Writer发送任务，Reviewer会自动处理审查
task_result = client.agents.messages.create(
    agent_id=writer.id,
    input="帮我写一个快速排序函数"
)

七、架构实现原理

7.1 上下文窗口的”虚拟化”

Letta的核心思想可以用一个类比来理解：

1
2
3
4
5
6
传统LLM的上下文窗口 = 电脑的寄存器
Letta的分层记忆 = 电脑的RAM + 磁盘 + OS调度

当寄存器（上下文）不够用时，
不是扩展寄存器（不可能），
而是让OS（Letta）来管理分页。
flowchart TB
    subgraph LLM视角["🤖 LLM的视角（看起来无限大）"]
        INFINITE["虚拟上下文<br/>包含所有历史对话<br/>感觉拥有无限记忆"]
    end
    
    subgraph 实际管理["💾 实际发生的事"]
        WINDOW["实际上下文窗口<br/>2048/4096/128K tokens"]
        CORE["Core Memory<br/>64个记忆块<br/>始终在窗口内"]
        ARCH["Archival Memory<br/>向量存储<br/>按需召回"]
    end
    
    subgraph 调度层["⚙️ Letta调度器"]
        LOAD["加载(Load)<br/>从Archival到Core"]
        STORE["存储(Store)<br/>从Core到Archival"]
        EVICT["驱逐(Evict)<br/>清理不重要的记忆"]
    end
    
    INFINITE -.外观欺骗.-> 实际管理
    调度层 --> LOAD & STORE & EVICT
    LOAD -.召回.-> INFINITE
    
    style LLM视角 fill:#98FB98,stroke:#228B22
    style 实际管理 fill:#87CEEB,stroke:#4169E1
    style 调度层 fill:#DDA0DD,stroke:#9370DB

7.2 记忆重要性的判断

Letta使用LLM自己来判断记忆的重要性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def judge_importance(memory_block, context):
    """
    让LLM判断一段记忆是否重要
    """
    prompt = f"""
    评估以下记忆片段的重要性：
    
    记忆: {memory_block.value}
    
    当前对话: {context.summary}
    
    考虑因素:
    - 这段记忆是否影响当前对话的理解？
    - 这是用户反复提到的信息吗？
    - 这是Agent需要长期记住的关键事实吗？
    
    给出0-10的重要性评分和简短理由。
    """
    
    response = llm.generate(prompt)
    score = parse_importance_score(response)
    return score

7.3 Compaction的触发与执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class CompactionManager:
    def __init__(self, core_limit_pct=0.8):
        self.core_limit = core_limit_pct
    
    def should_trigger(self, agent_state) -> bool:
        """判断是否需要触发压缩"""
        usage = agent_state.core_memory_usage
        return usage > self.core_limit
    
    def execute(self, agent) -> CompactionResult:
        """执行压缩流程"""
        # 1. 读取所有Core Memory
        core_blocks = agent.get_core_memory()
        
        # 2. 对每个Block评分
        scored_blocks = []
        for block in core_blocks:
            importance = judge_importance(block, agent.current_context)
            scored_blocks.append((block, importance))
        
        # 3. 按重要性排序
        scored_blocks.sort(key=lambda x: x[1], reverse=True)
        
        # 4. 保留最重要的N个块，其余归档
        keep_count = int(len(scored_blocks) * 0.6)  # 保留60%
        
        kept = [b for b, s in scored_blocks[:keep_count]]
        archived = [b for b, s in scored_blocks[keep_count:]]
        
        # 5. 更新记忆
        agent.update_core_memory(kept)
        agent.add_to_archival(archived)
        
        return CompactionResult(kept=kept, archived=archived)

八、局限性与发展

8.1 当前局限

flowchart TB
    subgraph 局限性["⚠️ Letta的局限性"]
        L1["LLM能力依赖<br/>Compaction质量取决于LLM"]
        L2["延迟开销<br/>检索和压缩带来响应延迟"]
        L3["记忆准确性<br/>LLM可能"忘记"重要事实"]
        L4["架构复杂度<br/>比简单Agent框架复杂很多"]
    end
    
    style 局限性 fill:#FFA07A,stroke:#FF6347

8.2 未来发展方向

timeline
    title Letta发展路线图
    2026 Q2 : 记忆压缩算法优化
         : 更智能的自动遗忘
    2026 Q3 : 多模态记忆支持
         : 图像/视频记忆存储
    2026 Q4 : 个性化记忆模型
         : 针对用户定制压缩策略
    2027+ : 跨Agent持续学习
         : 多Agent协作中共同进化

九、总结

Letta解决的是一个根本性问题：LLM的上下文窗口有限，但人类的知识和需求是无限的。

它的解法——让Agent像操作系统管理内存一样管理记忆——看似简单，实际上打开了一扇新的大门：

1
2
传统Agent:     每次对话都是新的开始
Letta Agent:   持续演进的生命体

核心洞察：

  • 分层记忆比单一上下文更接近人类认知
  • 主动管理比被动检索更高效
  • OS思想给LLM架构带来了新的设计语言

Letta目前仍处于快速发展阶段，它的架构思路正在影响整个Agent设计领域。如果你在构建需要”记住用户”或”持续成长”的AI应用，Letta绝对值得深入研究。

参考资料

资源链接
GitHubgithub.com/letta-ai/letta
官网letta.com
文档docs.letta.com
论文arXiv:2310.08560 (MemGPT)
模型排行榜leaderboard.letta.com
Discord社区discord.gg/letta

Letta的思想可以用一句话总结：不是让LLM的上下文窗口变大，而是让它学会像我们一样——记住重要的，忘掉不重要的。