跳到主内容
快讯直播
AI智模界
教程

多会话智能体跨会话隔离审计实战

这篇能做出什么

围绕 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 变成必填项,把过滤做两层,把测试做成双向断言——这三件事做完,再遇到同类的公开事件,你可以直接拿自己的测试报告回答。

AI 生成本文由 AI 基于公开信息自动生成,仅供参考。