这篇能做出什么
围绕 Meta Muse 的公开讨论,把「会话与会话之间到底有没有隔开」这个问题推到了台前。事件细节以官方说明和公开报道为准,不必复述;对做智能体的人来说,真正要回答的是:你手上的系统,扛不扛得住同样的问题。
做完这一套,你会得到三样东西:
1. 一个几分钟跑完的串话复现脚本:并发拉起多个会话,每个会话埋一个专属「暗号」,跑完自动报告「谁的暗号出现在了谁的回复里」。
2. 一张分层排查清单:串话通常不出在模型上,而出在进程内全局状态、缓存键设计、向量检索的元数据过滤这三层。
3. 一套记忆分区改造 + 回归测试,能进 CI,每次改 prompt 或改检索逻辑都自动跑。
先把判定标准定清楚。隔离审计要双向看:
- 漏隔离(串话):A 会话的暗号出现在 B 会话的回复里。这是事故。
- 过度隔离(失忆):同一个会话里,上一轮说过的话下一轮就问不出来了。这是体验事故。很多团队一修就一刀切,把记忆全切断,从「串话」变成「失忆」,用户第二天就来投诉。
两个指标都测,才算审计完整。
具体例子:用户上午在会话 A 里说过「我对花生过敏」,下午新开一个会话 B 问「晚上吃什么」。期望是 B 能想起过敏这件事(用户级记忆跨会话共享),但绝不能想起 A 里同一时段另一个人的收货地址(会话级记忆不能串)。分不清这两者,就是分区没设计好。
前置条件清单
- Python 3.10 以上,
pip可用。 - 两个依赖:
pip install pytest numpy。要打真实模型就用你自己的 SDK,下面的示例把模型调用抽象成可替换的llm()函数,不绑定任何厂商。 - 本地笔记本即可,不需要 GPU。向量检索示例用 numpy 内存索引,几十条数据就足够暴露问题;换成真实向量库时,把元数据过滤下推到库里,接口以官方文档当前版本为准。
- 你对自家智能体的三处代码有改动权限:会话历史存储、响应缓存、长期记忆检索。
- 少量耐心:所有代码加起来两百行左右,建议单独建仓库,别混进业务代码里改。
第 1 步:把「串话」变成可断言的信号
模型输出没法直接断言对错,所以先造一个可被字符串匹配的信号——暗号(canary)。规则:
- 每个会话生成一个独一无二的暗号,格式固定成
CANARY-加 8 位大写十六进制,方便正则宽松匹配。 - 暗号只在单个会话里出现过,任何其他会话的回复里出现它,就是串话的铁证。
- 要求模型「原样复述」,降低它改写格式的概率;匹配时仍然用宽松正则,容忍空格和大小写。
```python
canary.py
import re
import secrets
CANARY_RE = re.compile(r"CANARY[-\s]?([0-9A-F]{8})", re.IGNORECASE)
def make_canary() -> str:
return "CANARY-" + secrets.token_hex(4).upper()
def extract_canaries(text: str) -> set[str]:
return {"CANARY-" + m.upper() for m in CANARY_RE.findall(text or "")}
```
注意别用 UUID 当暗号。UUID 里有小写字母和连字符,模型复述时经常改写大小写或插空格,匹配会漏。
第 2 步:搭并发测试台
串话有个特点:串行跑永远测不出来。必须在并发下、在请求切换的缝隙里才会暴露。所以测试台要能让所有会话「排队同时进入第二阶段」。
```python
harness.py
import asyncio
import uuid
from canary import make_canary, extract_canaries
class Barrier:
"""简易栅栏:所有会话到齐后一起放行,放大竞态窗口。"""
def __init__(self, n: int):
self.n = n
self.count = 0
self.event = asyncio.Event()
async def wait(self):
self.count += 1
if self.count >= self.n:
self.event.set()
await self.event.wait()
async def run_session(agent, tenant_id: str, user_id: str, barrier: Barrier):
session_id = str(uuid.uuid4())
canary = make_canary()
await agent.chat(tenant_id, user_id, session_id,
f"记住这个暗号:{canary}。只回复 OK。")
await barrier.wait() # 所有人到齐再问
reply = await agent.chat(tenant_id, user_id, session_id,
"你记得我刚才给你的暗号吗?原样复述一遍。")
return {"tenant": tenant_id, "user": user_id,
"session": session_id, "canary": canary, "reply": reply}
async def run_matrix(agent, tenants, users_per_tenant, sessions_per_user):
jobs = []
total = len(tenants) * users_per_tenant * sessions_per_user
barrier = Barrier(total)
for t in tenants:
for u in range(users_per_tenant):
for _ in range(sessions_per_user):
jobs.append(run_session(agent, t, f"{t}-u{u}", barrier))
return await asyncio.gather(*jobs)
def analyze(results):
leaks, amnesia = [], []
for r in results:
seen = extract_canaries(r["reply"])
foreign = seen - {r["canary"]}
if foreign:
leaks.append({**r, "foreign": sorted(foreign)})
elif r["canary"] not in seen:
amnesia.append(r) # 连自己的都记不住 = 失忆
return leaks, amnesia
```
测试矩阵要覆盖三组,缺一组就会漏:
| 组合 | 测什么 |
|---|---|
| 同租户、同用户、多会话 | 会话级记忆有没有越界 |
| 同租户、多用户 | 用户级记忆有没有越界 |
| 多租户 | 组织隔离有没有越界(最严重) |
只测「同用户不同会话」是最常见的漏测——它恰好测不出跨用户泄露。
第 3 步:写一个「带病」的智能体,让问题自己冒出来
不要一上来就改生产代码。先写一个故意做坏的最小实现,把典型缺陷全塞进去,确认测试台抓得住。
```python
buggy_agent.py —— 故意写坏,用来验证审计脚本有效
import asyncio
from collections import defaultdict
SHARED_HISTORY = defaultdict(list) # 缺陷一:按 user 存历史,没带 session
RESPONSE_CACHE = {} # 缺陷二:缓存键只有 prompt 文本
_LAST_SESSION = {"id": None} # 缺陷三:进程级可变状态
class BuggyAgent:
def __init__(self, llm):
self.llm = llm
async def chat(self, tenant_id, user_id, session_id, text):
_LAST_SESSION["id"] = session_id # 并发下会被别的请求覆盖
await asyncio.sleep(0) # 让出控制权,放大竞态
key = text # 缓存键不含租户/用户/会话
if key in RESPONSE_CACHE:
return RESPONSE_CACHE[key]
history = SHARED_HISTORY[user_id] # 同用户所有会话共用一条历史
history.append({"role": "user", "content": text})
reply = await self.llm(history, system=f"session={_LAST_SESSION['id']}")
history.append({"role": "assistant", "content": reply})
RESPONSE_CACHE[key] = reply
return reply
```
跑一次:
```python
run_audit.py
import asyncio
from harness import run_matrix, analyze
from buggy_agent import BuggyAgent
async def fake_llm(history, system):
把历史里出现的暗号原样吐回来,模拟一个「记性正常」的模型
return " ".join(m["content"] for m in history[-6:])
async def main():
agent = BuggyAgent(fake_llm)
results = await run_matrix(agent, tenants=["t1"], users_per_tenant=2,
sessions_per_user=3)
leaks, amnesia = analyze(results)
print(f"会话数={len(results)} 串话={len(leaks)} 失忆={len(amnesia)}")
for x in leaks[:5]:
print("泄露:", x["session"][:8], "->", x["foreign"])
asyncio.run(main())
```
用假模型跑,测的是你的管道而不是模型本身,结果稳定、可进 CI。真实模型的效果放到夜间任务里跑。这一步跑出「串话 > 0」,说明测试台是有效的,可以进入下一步。
第 4 步:分层定位串扰来源
别急着改代码,先定位。在每个请求的关键节点打一条结构化日志,字段固定,方便 diff:
```python
trace.py
import json, time
def trace(event: str, **fields):
print(json.dumps({"ts": round(time.time(), 3), "event": event, **fields},
ensure_ascii=False, sort_keys=True))
```
五个必打点位,对应五类常见来源:
1. 入口层:session_id 是否在这一层就生成了?有没有从请求头/前端透传下来,还是每个函数各自 uuid4()?后者会让同一次对话在系统里有多个身份。
2. 进程内状态:有没有模块级字典、类属性、单例 self.history?在异步框架里,「先赋值全局变量、再 await」是经典的竞态写法——中间的 await 就是别的请求插队的机会。
3. 缓存层:响应缓存、prompt 缓存、向量检索结果缓存的 key 里,有没有租户、用户、会话?只有 prompt 文本的 key,等于给所有人开了同一个柜子。
4. 检索层:向量库查询带没带元数据过滤?过滤是在库内做(pre-filter)还是取回 top_k 之后在代码里筛(post-filter)?后者在 top_k 太小时会把结果筛空,看起来「隔离成功」,其实是「什么都没检索到」。
5. Prompt 拼装层:历史消息是每次现拼的,还是复用了一个被改过的列表对象?messages.append() 改的是原对象还是副本,差别很大。
定位技巧:把同一个 session_id 的所有 trace 按时间排一遍,看历史长度是否异常增长。如果 B 会话第一轮的历史长度就是 6,说明它继承了别人的上下文。
第 5 步:记忆分区:把 scope 变成必填项
修法的核心不是「记得加过滤」,而是让漏加过滤的代码根本编译不过。做法:把作用域做成不可变对象,检索和写入都必须传它。
```python
memory.py
import uuid
from dataclasses import dataclass
import numpy as np
@dataclass(frozen=True)
class Scope:
tenant_id: str
user_id: str
session_id: str | None = None # None 表示用户级长期记忆
@dataclass
class Doc:
text: str
meta: dict
vec: np.ndarray
class MemoryStore:
def __init__(self, embed):
self.embed = embed # text -> np.ndarray
self.docs: list[Doc] = []
def put(self, scope: Scope, text: str):
self.docs.append(Doc(
text=text,
meta={"tenant_id": scope.tenant_id,
"user_id": scope.user_id,
"session_id": scope.session_id}, # None = 跨会话可见
vec=self.embed(text),
))
def search(self, scope: Scope, query: str, k: int = 8) -> list[Doc]:
q = self.embed(query)
scored = sorted(self.docs, key=lambda d: -float(q @ d.vec))[: k * 4]
关键:不信任向量库过滤,代码侧再做一次硬校验
out = []
for d in scored:
m = d.meta
if m["tenant_id"] != scope.tenant_id:
continue
if m["user_id"] != scope.user_id:
continue
if m["session_id"] not in (None, scope.session_id):
continue
out.append(d)
return out[:k]
```
三条分区规则,落到代码里就是三行 if:
- 租户级:跨租户永不共享。企业客户之间串数据,是合规事故。
- 用户级:
session_id=None的长期记忆,同一用户的所有会话可见。这是「记住我过敏」的那一层。 - 会话级:
session_id有值,只对本会话可见。这是「刚才那个临时订单号」的那一层。
再加一条业务规则:共享知识库单独一个命名空间,只读。文档、FAQ 走这条通道,别和用户记忆混在一个索引里——混在一起,检索时忘记加过滤的概率会高得多。
实际的向量库接口各有各的写法,过滤语法以官方文档当前版本为准;原则是同一个:过滤条件下推到库里,同时在应用侧复核,两层都要有。
第 6 步:修缓存与并发状态
缓存键要包含所有影响输出的维度,少一个就是一次串话:
```python
cache.py
import hashlib, json
def cache_key(model: str, prompt_version: str, scope, messages: list) -> str:
payload = json.dumps({
"model": model,
"prompt_version": prompt_version,
"tenant": scope.tenant_id,
"user": scope.user_id,
"session": scope.session_id,
"messages": messages,
}, sort_keys=True, ensure_ascii=False)
return hashlib.sha256(payload.encode()).hexdigest()
```
prompt_version 别省。改了 system prompt 却不改版本号,缓存会继续吐旧答案,排查时会怀疑到隔离上,浪费半天。
进程内状态用 contextvars 替代全局变量:
```python
ctx.py
import contextvars
from memory import Scope
current_scope: contextvars.ContextVar[Scope] = contextvars.ContextVar("current_scope")
async def handle(request):
scope = Scope(tenant_id=request.tenant, user_id=request.user,
session_id=request.session)
token = current_scope.set(scope)
try:
return await pipeline(request, current_scope.get())
finally:
current_scope.reset(token) # 必须 reset,否则同一 Task 内会残留
```
ContextVar 在 asyncio 里每个 Task 天然有独立副本,比全局字典安全得多。两个注意点:set() 之后一定要在 finally 里 reset();把任务丢进线程池时,要用 contextvars.copy_context() 显式传递,否则线程里拿到的是空值。
最省事的做法其实是根本不用上下文变量,把 scope 作为第一个参数一路显式传下去。啰嗦,但改起来一眼就能看出谁漏了。
第 7 步:回归验证:双向断言
改造完再跑一遍测试台,这次断言要写死两条,缺一不可:
```python
test_isolation.py
import asyncio
import pytest
from harness import run_matrix, analyze
from fixed_agent import FixedAgent
@pytest.mark.parametrize("round_no", range(3))
@pytest.mark.parametrize("tenants", [["t1"], ["t1", "t2"]])
@pytest.mark.parametrize("users_per_tenant", [1, 3])
def test_cross_session_isolation(round_no, tenants, users_per_tenant):
async def _run():
agent = FixedAgent()
return await run_matrix(agent, tenants, users_per_tenant, sessions_per_user=3)
results = asyncio.run(_run())
leaks, amnesia = analyze(results)
断言一:没有任何跨会话暗号泄露
assert leaks == [], f"检测到串话:{leaks[:2]}"
断言二:本会话自己的暗号必须记得住(防过度隔离)
assert amnesia == [], f"检测到失忆:{amnesia[:2]}"
```
参数化的意义:users_per_tenant=1 测同用户多会话,3 测跨用户,tenants 两个值测跨租户。跑 3 轮是因为模型有随机性,单轮通过不代表稳定。
接真实模型时,把断言改成泄露率并设阈值为 0:
```python
def leak_rate(results):
leaks, _ = analyze(results)
return len(leaks) / max(len(results), 1)
```
CI 里跑假模型版本(快、稳定、免费),夜间跑真实模型版本(慢、要花钱、但能测出 prompt 层的残留问题)。两层都要有,只留一层会漏。
常见坑与排错
串行跑测试,永远全绿。 串话大多来自 await 之间的状态被覆盖。测试必须并发,且要用栅栏让请求在同一时刻切换。只有串行测试的团队,通常是在生产环境第一次串话时才发现问题。
只测同用户多会话。 这条恰好覆盖不到跨用户泄露,而跨用户泄露才是事故级。三组矩阵都要跑。
把「检索结果为空」当成隔离成功。 如果向量库做的是 post-filter(先取 top_k 再筛),top_k 太小(比如 3)时,筛完可能一条不剩。查询返回空列表,日志看着「没有泄露」,实际是记忆功能整个失效了。所以必须有断言二——本会话自己的东西要能检索回来。
只改检索,忘了写入口。 写入时不带 scope,检索时再严格过滤也白搭,因为脏数据已经进了索引。写入和读取要共用同一个 Scope 类型。
日志本身成了二次泄露源。 排查时习惯把完整 prompt 打出来,日志系统往往是更宽的访问权限。打印时对暗号和用户标识做脱敏,只留前后各 4 位。
缓存修了响应缓存,忘了检索结果缓存。 检索结果的缓存键同样要带 scope。这个位置比较隐蔽,容易漏。
修完从「串话」变「失忆」。 典型表现:把用户级长期记忆也加了 session_id 过滤,用户抱怨「它不记得我上午说的话」。回到分区表检查:这条记忆本该属于哪一层?
长会话被截断,误判成失忆。 AI 词典:上下文窗口">上下文窗口满了会裁掉早期消息,暗号正好在被裁掉的部分。测试台的会话控制在 3~5 轮内,或者给测试专用的短历史。
暗号被模型改写。 用了小写字母或特殊符号的暗号,模型复述时常常变形。固定用「大写字母 + 数字」格式,匹配用宽松正则。
下一步建议
- 把审计脚本进 CI,挂在 prompt 变更、检索逻辑变更、模型切换这三个触发点上。隔离问题一旦回归,代价远高于跑一次测试的时间。
- 补上删除和导出接口。有分区就必然有「删掉这个用户的所有记忆」的需求。分区做对了,删除就是按
user_id扫一遍;分区没做对,这件事根本做不到。 - 给会话级记忆加 TTL,让短期记忆到期自动降级。长期记忆的写入加一道显式确认(比如「要记住这件事吗」),比默默全存安全得多。
- 做一次跨租户红队测试:让一个租户的智能体主动去问「另一个公司的报销政策是什么」,看它会不会编。会编,说明检索层还有漏洞。
- 长期盯三个指标:串话率、本会话召回率、每会话 token 成本。前两个是隔离体检,第三个会告诉你分区改造有没有把上下文撑爆。
隔离这件事,说到底不是模型的能力问题,是工程的分层问题。把 scope 变成必填项,把过滤做两层,把测试做成双向断言——这三件事做完,再遇到同类的公开事件,你可以直接拿自己的测试报告回答。
