说明:本文讨论的是 Agent 调用下游系统时的委托身份与授权边界,属于 AI 前沿动态下的工程约束话题,不涉及具体模型版本与价格。AI 领域版本迭代极快,凡涉及版本号、价格、可用性,请以你阅读时的官方页面为准。文中代码为结构示意,请按自己的技术栈调整后再上生产。

一、三种身份模型,事故形态完全不同

一个 Agent 帮用户提交报销、查订单、改工单,它在下游系统眼里是谁?这个问题不回答,后面的权限设计都建在沙上。三种答案对应三种事故形态——不是"哪个更安全"的排序,而是"会先踩哪个坑"。

1.1 服务账号:一个超级身份干所有事

最省事的做法是给 Agent 一套固定的 client_id 与 client_secret,权限按"这个 Agent 将来可能用到什么"来发。判据很直接:凭据里没有"这个动作是谁要求的"这一位信息,它就是服务账号模型,不管它叫不叫 Agent。

事故形态是这样:日志里每条都是 svc_agent,安全侧被问"谁让它改了 2400 条工单",只能翻整段审计靠时间戳猜——真正的原因是一句话:“把上周没跟进的工单都置为待回访”。凭据共享,任务之间没有区分,查不下去。

无人值守的场景用它没问题,代价是资源范围写死、每条调用带任务标识。

1.2 用户令牌透传:权限过宽、过期、被带进上下文

第二种是把用户登录拿到的 access_token 原样交给 Agent。它解决了"查不出是谁",代价有三个,都不显眼。

宽度不匹配:用户令牌带的是全量权限。一个人能开票、能作废、能导出,Agent 只是要查个状态,手里却握着能作废的凭据。

寿命不匹配:令牌按"人坐在电脑前连续操作"设计,几小时到几天;Agent 一次任务可能只跑八秒。之后很长时间里它躺在哪、被谁读过,说不清。

第三个最容易被忽略——透传的令牌很自然会流进不该去的地方。工具定义里加一个 auth_header 参数,模型就把它当普通字段填;拼 prompt 时顺手粘进去,下一轮就复述出来;日志里一行 headers=%s,异常分支照样触发。

1.3 委托身份:短期、按次收窄、双主体留痕

第三种是委托:Agent 用自己的身份证明"我是谁",同时携带"我代表谁",换一个只对本次任务有效、只覆盖所需动作的令牌。三个可检验的特征——有效期分钟级、scope 按任务算出来、令牌里有两个主体。

维度服务账号用户令牌透传委托身份
凭据主体一个固定服务身份用户本人Agent 身份 + 被代表用户
权限宽度按最大用途发放用户全量权限本次任务算出的 scope
有效期长期,按月计与登录会话同寿命分钟级,按任务续
撤销粒度只能停用整个账号踢掉整个会话可按任务、按次撤销
事后追溯只能追到服务追到人,追不到哪次任务发起人、执行身份、凭据来源齐全
典型事故一次误操作波及全租户令牌出现在日志或上下文里交换链配错导致范围过宽

委托身份不免事故,只换了形状。透传出事是凭据泄漏,扫描能发现;委托出事是 scope 申请太大或 audience 写成通配,只能靠配置评审和验收用例兜住。

二、Agent 自己的权限与用户的权限要取交集

委托身份最容易做错的地方,是把"换到了用户令牌"当成终点。换完还有第二个问题:这个 Agent 本身,被允许碰这个系统吗?两件事主体不同、审批人不同、失效节奏不同,混在一起判就一定漏。

2.1 两次判定:能不能碰这个系统、能不能碰这条数据

第一维的主体是 Agent:有没有在下游注册、有没有该接口的调用许可、这个租户有没有开这项能力。这类许可由平台侧发放,变更慢,可缓存几分钟。

第二维的主体是被代表的用户:他对这条资源有没有这个动作。这类判定由业务侧给出,实时性强,撤权要立刻生效。

判据一句话:任一为否即拒,两次结果都进审计。反例是最常见的只做第二维——用户对自己的订单当然有读权限,Agent 用他的令牌读到了;可那个 Agent 属于另一条业务线,本不该接订单系统。越权发生了,权限系统认为一切正常,因为它只被问了半个问题。

⚠️ 代码待验证

class Deny(Exception):
    def __init__(self, dim, missing, hint):
        self.dim, self.missing, self.hint = dim, missing, hint

def authorize(agent, user, resource, action):
    # 第一维:Agent 对下游系统的接入许可,平台侧发放,可缓存
    if not agent.can_call(resource.system, action):
        raise Deny("agent_scope", f"{resource.system}:{action}",
                   "该 Agent 未接入此系统,联系平台方开通")
    # 第二维:被代表用户对具体资源的动作,业务侧实时判定
    if not user.can_act(resource.tenant, resource.id, action):
        raise Deny("user_scope", f"{resource.type}:{action}",
                   "你对这条资源无此权限,联系资源所有者")
    # 下发的是交集,不是并集
    return sorted(set(agent.scopes[action]) & set(user.scopes[action]))

最后一行是整套模型的全部意义。写成并集的症状很典型:Agent 有导出权限、用户没有,用户通过 Agent 把明细导走了。两边单独看都"有权限",测不出来。

2.2 交集为空时的反馈:说清楚缺哪一项

返回 403 加一句"无权限",最省事也最贵:用户不知道是系统坏了还是权限不够,会重试、换措辞、找客服。

结构化反馈带三样:缺哪一维(agent_scope 还是 user_scope)、缺哪个 scope、找谁申请。用户自己能判断该申请还是平台配错了,工单量会明显下降。

约束要同时满足:反馈不能泄露资源存在性。用户连"有这条记录"都不该知道时,只回"当前无法完成此项操作",细节留在服务端审计。判据不是"资源重不重要",而是"存在性本身是否敏感",这两个判断经常给出不同答案。

2.3 代理链:A 调 B 调 C 时,主体怎么一路带下去

规划 Agent 接到任务,交给检索 Agent 找材料,检索 Agent 再调落库 Agent 写结果。每一跳都要保留两样:原始发起人,和这一跳的执行者。

做法是每跳单独交换、执行者链累加,而不是把上一跳的令牌转手。RFC 8693 的 act claim 支持嵌套,保留最近两跳够定位;全链会让令牌体积随任务深度膨胀,还容易顶到头部长度限制。

反例:B 直接拿 A 的令牌调 C,执行者字段空着,出了问题分不清是 A 的判断错还是 B 的实现错,而两者的修复责任人在两个团队。

三、令牌交换怎么做

交换是标准动作,出错集中在几个参数上。这一章把请求拆开看,再说收窄和续期。

3.1 交换的输入与输出:谁换、换什么、换成什么范围

一个交换请求回答四个问题:谁在换(调用方 client 身份)、代表谁(subject_token)、换给谁(audience)、要多大范围(scope)。四个都写清,交换才可审计。

输出是新的 access_token:sub 仍是被代表的用户,act 是当前 Agent,aud 是目标系统,scope 是收窄后的集合。判据是返回后比对一次——返回的 scope 与请求不一致时,按两者交集用。

⚠️ 代码待验证

# RFC 8693 令牌交换:表单编码,字段名按规范写
curl -sS -X POST https://auth.example.com/oauth2/token \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -u "agent-billing:${AGENT_CLIENT_SECRET}" \
  --data-urlencode "grant_type=urn:ietf:params:oauth:grant-type:token-exchange" \
  --data-urlencode "subject_token=${USER_ACCESS_TOKEN}" \
  --data-urlencode "subject_token_type=urn:ietf:params:oauth:token-type:access_token" \
  --data-urlencode "requested_token_type=urn:ietf:params:oauth:token-type:access_token" \
  --data-urlencode "audience=https://api.example.com/invoice" \
  --data-urlencode "scope=invoice:read invoice:submit" \
  --data-urlencode "actor_token=${AGENT_ACTOR_TOKEN}" \
  --data-urlencode "actor_token_type=urn:ietf:params:oauth:token-type:jwt"

三个字段最容易写错。audience 不是 scope 的一部分,写宽或不写,换出来的令牌能调所有接入同一授权服务器的接口。actor_token 缺省时 act 为空,双主体当场退化成单主体。subject_token_type 与实际类型不一致时,有的实现不报错而是按默认类型解析,错误推到调下游才暴露。

3.2 范围收窄:只申请这次任务真正需要的

能收多窄取决于下游的 scope 设计。下游只给一个 invoice:write,Agent 就没法只申请提交不含作废,这时收窄要落在代理层的二次判断上。

判据:scope 名字里带动作,且这个动作对得上用户理解的业务语义。*:manage、*:all 在 Agent 场景里等于没收窄。

任务应申请不该带原因
查报销单状态invoice:readinvoice:write只读任务没有写路径,带上就是多余授权
代填并提交报销invoice:read invoice:submitinvoice:void提交与作废是两个业务动作,审批人不同
生成月度对账ledger:readledger:export导出等价于把明细带出系统边界
批量调整工单优先级ticket:updateticket:admin管理动作包含改配置,不属于任务范围

第二行是过度收窄的反例:只给 invoice:submit 不给 invoice:read,Agent 提交前没法核对金额,只能盲填。scope 按"完成任务的最小闭包"给,不按"看起来最少的那个"给。

3.3 有效期与刷新:任务跑两小时,令牌只有十分钟

短期令牌把泄漏窗口压到十分钟,代价是长任务要续。三种做法:任务级令牌加后台续期,适合多数场景;分步令牌,步骤之间权限差别大时用;一次性令牌,每次调用换一次,只对写操作开,因为交换本身有成本。

续期要设上限。正常任务不会续二十次,续到这个数通常意味着循环或卡在重试里,继续续只是把问题拖长。

⚠️ 代码待验证

import time

class TokenLease:
    """按任务持有的短期令牌:提前 60 秒续,续期次数封顶。"""
    def __init__(self, exchange, max_renew=6):
        self._exchange = exchange          # () -> (token, ttl_seconds)
        self._max_renew = max_renew
        self._renewed = 0
        self._token, ttl = exchange()
        self._exp = time.monotonic() + ttl

    def get(self):
        if time.monotonic() < self._exp - 60:
            return self._token
        if self._renewed >= self._max_renew:
            raise RuntimeError("renew limit hit, abort task")
        # 续期时重新读一次授权状态:用户中途被撤权,这里应当失败
        self._token, ttl = self._exchange()
        self._exp = time.monotonic() + ttl
        self._renewed += 1
        return self._token

    def invalidate(self):
        self._token, self._exp = None, 0.0

两处细节。时间用 monotonic 不用墙钟,机器对时会让墙钟往回跳,跳一次就可能在"刚续过"之后立刻再续一次。续期时重读授权状态,把第五章"长任务中被撤权"解决了一半,剩下的一半是窗口长度,它等于令牌的剩余有效期。

四、令牌放在哪

凭据管理的前半段是"怎么换到",后半段是"换到之后放哪"。后半段出事更频繁,因为它不涉及设计,只涉及习惯。

4.1 不进上下文、不进日志、不进 trace 的属性字段

上下文:任何拼进 prompt 的字符串都会被模型看见,看见就有机会复述。这不是模型"不听话",是工作机制决定的,别指望提示词解决。

日志:请求头、请求体、异常堆栈三处默认带凭据。最隐蔽的是异常分支——正常路径的日志级别调高了,异常路径的 exc_info=True 还在,它会把整个请求对象序列化出来。

trace:span 的 attributes 里记 http.request.header 是不少埋点库的默认行为。判据是在网关做一次正则扫描,Bearer\s+[A-Za-z0-9._-]{20,} 命中就丢弃并计数;计数不为零,说明上游还在往这送,只是被兜住了。

4.2 工具代理模式:模型只见工具名,凭据在代理层注入

模型看到的工具定义是 submit_invoice(invoice_id, amount),没有 auth 参数,没有 header 参数。代理层拿任务上下文里的租约,注入 Authorization 头,再转发。

schema 里不能出现 token、auth、authorization、header 这类字段名。有的话模型会试着填,填错还占掉一个参数位。

⚠️ 代码待验证

def call_tool(task, tool_name, args, lease, http):
    """模型只给 tool_name 与 args,凭据在这一层注入。"""
    spec = TOOL_REGISTRY[tool_name]
    if any(k in args for k in ("token", "auth", "authorization", "header")):
        raise ValueError(f"credential-like arg rejected: {tool_name}")

    headers = {"Authorization": f"Bearer {lease.get()}"}
    resp = http.request(
        spec.method, spec.url,           # 地址来自注册表,不来自模型
        json=args,
        headers=headers,
        timeout=spec.timeout,            # 单次调用超时,别用全局默认
    )
    if resp.status_code == 401:
        lease.invalidate()               # 令牌失效就作废整份租约
        raise DownstreamAuthError(tool_name)
    return resp.json()

spec.url 来自注册表这一行,比凭据本身更要紧。模型能决定请求地址,就能让带凭据的请求发到任意地方。lease.invalidate() 同样必要:401 通常意味着令牌被撤销,继续用同一份租约只会连续失败,还给监控造一串噪声。

4.3 并发与缓存:同一用户多个任务共用一份短期凭据的边界

同一用户同时跑三个任务能不能共用令牌?可以,前提是三个条件同时满足:scope 完全一致、租户相同、可撤销性要求相同。任一不满足就单独换。

缓存键最容易写错。按 user_id 做键,写任务的 scope 被读任务复用,读任务凭空有了写权限。正确的键是 (tenant, user, audience, scope_hash) 四元组,四个都不能省——省掉 audience 会让面向不同系统的令牌互相串。

并发续期要做 single-flight。十个请求同时发现令牌将过期,不合并就发起十次交换,撞上频率限制后一起失败,报的错还是"授权失败",排查方向直接跑偏。

五、越权的六种来路

身份模型设计对了,越权照样发生,因为它不来自设计,来自实现里的空隙。六种来路按位置分三组,两两一组。

来路触发条件典型现象拦截点
提示注入要求"用管理员身份执行"上下文混入外部文本模型生成越权的工具调用身份不在上下文里,参数里无身份可填
参数里塞别人的资源 ID模型或被诱导改了 id用 A 的令牌操作 B 的资源调用前按令牌主体校验归属
跨租户缓存缓存键漏了租户返回的数据对不上,字段缺失键含租户,命中后二次校验
长任务执行中权限被撤销任务时长超过撤权生效时间任务后半段仍在写续期时重查授权状态
子 Agent 继承父 Agent 全部权限子任务由父任务派生子任务能调父任务全部工具子任务单独交换,scope 取子集
批处理里混用身份一次处理多个用户的数据用第一个用户的令牌跑完整批逐条交换,或逐条校验归属

5.1 模型侧的两条:提示注入与对象级越权

提示注入的处理方式不是"让模型别听",而是让它听了也没用。身份不在上下文里,模型没有可改的东西;工具参数里没有身份字段,它没有可填的位置。判据:把所有能改变"以谁的身份执行"的输入都从上下文里拿掉,只留数据。

对象级越权的入口太平常:接口按 id 操作,id 来自模型。防御落在接口层——拿令牌里的 sub 比对资源所有者,不信请求体里的 tenant_id,也不信模型算出来的归属。

⚠️ 代码待验证

def load_owned(resource_type, resource_id, claims, store):
    """按令牌里的 sub 校验归属,不信任请求体里的 tenant_id。"""
    row = store.get(resource_type, resource_id)
    if row is None:
        raise NotFound()
    if row.tenant_id != claims["tenant"] or row.owner_id != claims["sub"]:
        audit.warn("ownership_mismatch", {
            "sub": claims["sub"], "tenant": claims["tenant"],
            "resource": f"{resource_type}:{resource_id}",
            "owner": row.owner_id,
        })
        raise NotFound()                 # 对外与"不存在"一致
    return row

两处 NotFound 是有意的。写成 Forbidden 等于告诉调用方"这个 id 存在",配合遍历就能数出别人有多少条记录。审计记真实原因,对外表现一致,这两件事分开做。

覆盖面上有个常见缺口:只在写接口做了归属校验,读接口漏了。读接口泄露的信息通常更完整。

5.2 基础设施侧的两条:跨租户缓存与子 Agent 继承

缓存漏租户是单租户测试永远发现不了的问题。上线前用双租户环境跑一遍,同一个 id 在两个租户下分别查,期望返回不同资源或都返回不存在,不能出现"两个租户拿到同一份数据"。

子 Agent 继承的问题出在省事上。派生一个只读子任务,父的租约里有写 scope,直接复用省了一次交换。判据写死:子任务 scope 必须是父的子集,且在派生时显式声明。派生数量通常不受控,一个规划任务可能派生几十个子任务,继承的代价被放大几十倍。

5.3 时间与批次上的两条:执行中被撤权、批处理混用身份

撤权到任务感知之间必然有窗口,缩短手段只有两个:令牌短、续期时重查授权。窗口上限等于令牌剩余有效期,写操作把 TTL 压到五分钟,窗口就是五分钟。读写分开设 TTL 值得做,因为写的后果不可回滚。

批处理逐条交换成本高,但能回答"每一条是谁授权的"。折中是服务身份读、逐条换成用户身份写——读靠逐条校验兜住,写必须换成真实主体。不可行的是用第一条记录的用户令牌跑完整批,日志里 500 条全是同一个 sub。

完整版资料清单:本文用到的身份模型对比表、交换字段清单与越权用例都整理在里面了,扫码即可获取:

配套资料获取

六、审计:一次调用记两个主体

委托模型的价值有一半在审计上。多记两个字段成本很低,它决定了出事那天能不能在一小时内说清影响范围。

6.1 发起人、执行身份、授权凭据的来源

三个字段缺一不可:sub 是发起人,act 是执行身份(含 Agent 标识与修订号),credential_source 说明凭据从哪来——交换得到的、缓存命中的、还是服务身份自带的。

判据:记录里 sub 与 act 相同,说明委托没生效——要么是服务账号,要么是透传。这两种都该单独拉一条监控看比例。

字段取值示例用来回答
subu_20871谁发起的
actagent:invoice-bot@r7谁执行的
credential_sourceexchange:aud=invoice-api凭据从哪来、范围多大
scopeinvoice:read invoice:submit这次被授权做了什么
decisionallow / deny:user_scope判定结果与拒绝维度
biz_reforder_id=SO-88213关联到哪笔业务

6.2 授权链路要能还原到「谁在什么时候批的」

委托链每一跳都要留可回溯的引用:交换请求的 jti、授权服务器返回的令牌标识、审批单据号。存引用不存内容——审批系统自己有留存策略,把正文抄进审计等于给同一份数据造第二份副本,删的时候两边都要删。

验收方法很土但有效:随机抽一条写操作审计,计时看能否在五分钟内还原"用户请求 → Agent 交换 → 审批 → 下游执行"四段,且时间戳单调递增。做不到,通常是某一跳只记了结果没记来源。

6.3 与业务日志的关联键

只用 trace_id 不够,它跨系统时经常被重写(网关重新生成、异步队列断开上下文),断一次就永久断掉。用业务侧本来就有的键做第二关联——订单号、工单号、单据号,这类键在业务日志里必然存在,人也看得懂。

⚠️ 代码待验证

{
  "ts": "2026-06-11T09:31:07.412+08:00",
  "trace_id": "7f3a91c2d4e8",
  "sub": "u_20871",
  "act": {"id": "agent:invoice-bot@r7", "chain": ["agent:planner@r2"]},
  "credential_source": "exchange:aud=https://api.example.com/invoice",
  "scope": ["invoice:read", "invoice:submit"],
  "action": "invoice.submit",
  "resource": "invoice:INV-202606-0417",
  "decision": "allow",
  "authz": {"agent_scope": "pass", "user_scope": "pass", "owner": "u_20871"},
  "approval_ref": "apr_20260611_0031",
  "biz_ref": {"order_id": "SO-88213", "request_id": "req_7f3a91c2"}
}

act.chain 只留最近一跳。authz 三个子项分开记,是为了区分"Agent 未接入"和"用户无权"这两种拒绝——处理人在两个团队,压成一个 deny 之后所有拒绝工单都会转错人。

七、落地顺序与验收

一次全开通常落到两个结果:业务方因为频繁的授权失败来投诉,或者为了不被投诉把 scope 放大到没意义。

7.1 先只读、再单点写、最后按范围开

第一阶段接一个系统、只给读 scope,跑两周。看三个数:拒绝率、任务平均时长、续期次数分布。拒绝率突然抬高多半是 scope 配窄了;续期出现长尾,说明有任务卡在某个重试里出不来。

第二阶段开一个写动作,要求它可逆——创建草稿而不是直接发布,加备注而不是改状态。准出条件写死:写操作的审计里 sub 与 act 齐全,且两者相同的记录数为零。

第三阶段按租户灰度。每开一批跑一遍 7.2 的四个用例,全过再开下一批。粒度用租户而不是用户,因为跨租户缓存只在租户边界上暴露。

7.2 四个验收用例:越权、过期、撤销、跨租户

四个用例都要在预发环境自动跑真实链路。前三个涉及跨服务的时间与状态,单测里 mock 出来的行为没有参考价值。

越权:用 A 的令牌请求 B 的资源 id,期望返回与"不存在"一致,审计里有 ownership_mismatch。过期:令牌 TTL 调成 30 秒、任务跑 90 秒,期望续期两次且任务成功;再把续期上限调到一次,期望任务中止而不是拿过期令牌继续调。撤销:任务跑到一半撤掉用户权限,期望下次续期失败、任务中止,中止前产生的写操作有回滚或补偿记录。跨租户:同一 id 在两个租户下分别调,期望结果不同或都返回不存在。

四个里最容易写成形式主义的是"撤销",因为"任务跑到一半"需要可控暂停点。做法是代理层留一个只在预发生效的注入点,让任务在指定步骤后等待。没有它,用例会退化成"撤权后新任务调不通",那测的是另一件事。

7.3 与审批、护栏层的分工:身份管「能不能」,审批管「要不要现在做」

身份层回答能力问题:这个主体有没有资格做这个动作。它不适合承载"这次要不要做"的判断,因为身份判定必须确定性、可缓存、毫秒级,而"要不要"要看业务上下文、要人参与,天然带延迟。

分工判据一句话:只看主体与资源关系的归身份层,要看金额、影响面、时间窗口的归审批层。

反例是把业务规则写进 scope。为表达"大额转账要审批"造一个 transfer:large,接着是"跨行要审批"“非工作时间要审批”,权限系统里堆起几十条业务规则,每次业务调整都要动授权配置,而授权配置的变更流程通常比业务代码重。正确做法是 scope 只到 transfer:create,阈值留给审批层。

完整版资料清单:本文用到的交换请求模板、审计字段表与四个验收用例都整理在里面了,扫码即可获取:

配套资料获取

附表 A:关键取舍一览

工程取舍原因依据章节
用委托身份而不是共享服务账号服务账号凭据不含"谁要求的"这一位信息,事后无法定位发起人一
不用用户令牌原样透传权限是用户全量、寿命按人机交互设计,且极易流进上下文与日志一
Agent 许可与用户权限取交集取并集会让 Agent 的权限溢出到用户身上,两边单独看都"有权限",测不出来二
拒绝原因分维度返回"Agent 未接入"与"用户无权"的处理人分属两个团队,合并后工单必然转错二、六
交换请求显式写 audience不写或写宽会让令牌能调所有接入同一授权服务器的接口三
令牌 TTL 分钟级 + 续期重查授权撤权窗口上限等于剩余有效期,续期是唯一能压缩它的位置三、五
凭据只在代理层注入工具 schema 里留 auth 字段,模型就会去填,填错还占参数位四
缓存键含租户与 audience漏租户会跨租户命中,漏 audience 会让面向不同系统的令牌串用四
子任务派生时显式声明 scope 子集默认继承会把父的可写范围放大到全部派生任务,而派生数量不受控五
审计记 sub 与 act 两个主体单主体记录只能追到人或者只能追到 Agent,都答不了"谁让它做的"六

附表 B:术语速查表

术语含义本文出现处
委托身份Agent 以自己的身份代表某用户行事,令牌中同时携带两个主体一、二
令牌交换用一个令牌换取范围更窄、受众更明确的另一个令牌的标准流程三
subject_token交换请求里代表被代表用户的那个令牌三
actor_token交换请求里代表执行方的令牌,决定 act 是否为空三
act claim令牌中标识实际执行者的声明,可嵌套以表达多跳代理二、三
audience令牌受众,限定它能被哪些下游接口接受三、四
最小闭包完成一次任务所必需的最小 scope 集合,含必要的读权限三
对象级越权主体有该动作的权限,但操作了不属于自己的那条资源五
双主体留痕审计中同时记录发起人与执行身份,两者缺一不可六

写在最后:这篇用到的资料

写这篇文章时,我把几个模型的官方文档、参数表和实测记录都对了一遍,顺手整理成几份配套的东西:

  • 大模型学习路线图:从 LLM 基础到 Agent 开发,各阶段该学什么、用什么资料
  • 大模型全套教程:按主题分好的视频与文档清单
  • 大模型实战好书:24 本,附每本适合的阶段

资料是我自己整理的,放在下面这个码上,扫码即可获取:

配套资料获取

大模型全套教程

大模型实战好书

添加时备注「大模型」,优先通过。

拿到之后建议先看学习路线图那一份,先定位自己在哪个阶段,再决定学什么,比一上来就啃框架效率高得多。

Logo

更多推荐