为管理型深度智能体添加身份标识

智能体并非匿名聊天机器人。一旦多个人（或多个公司）使用同一个部署，你就需要知道：这是谁的对话，以及智能体可能看到或操作谁的数据？ 身份标识使得一个部署可以安全地服务数千用户，且调用者之间不存在数据泄露。管理型深度智能体在每次运行前都会回答这个问题。你只需声明一个简单的契约，运行时就会对线程、记忆和凭据进行分区，确保调用者无法相互查看或影响。身份标识是可选启用的。没有 identity.ts 或 identity.py 的项目可以照常编译和部署。当你添加声明后，mda 会将身份验证、作用域以及一个冻结的 runtime.identity 对象注入到工具和中间件中。本页假设你已经有一个现有的管理型深度智能体项目，并且安装了 mda CLI。如果你是初次接触管理型深度智能体，请先阅读概述和快速入门。

托管深度代理目前处于私有测试阶段，仅在LangSmith Cloud的美国区域提供。加入等待列表以申请访问权限。

为什么身份标识对智能体至关重要

如果没有身份标识，一个管理型深度智能体对整个部署来说只有一个共享边界。这对于个人原型来说没问题。但一旦有真实用户出现，它就会崩溃：

问题所在	示例
共享记忆	Alice 要求智能体记住她的 API 偏好。Bob 开启一个新聊天，智能体就已经“知道” Alice 的详细信息了。
共享线程	任何能访问该部署的人都可以恢复或检查另一个用户的对话。
错误的凭据	智能体使用一个共享令牌调用 GitHub 或其他 API，因此每个用户都以同一个账户身份操作，或者你没有安全的方式代表已登录用户执行操作。

没有身份标识的深度智能体使这成为一个真实问题：它们会保持持久记忆、恢复长时间运行的线程，并代表用户调用工具。身份标识将“谁在调用？”从希望提示词或界面能区分开来，转变为强制的隔离。身份标识的一个关键好处是，下游工具调用可以代表已登录的用户操作，而不是作为一个共享的机器人账户。例如，当设置 credentials: "actor" 时，智能体会以 Alice 的身份调用 GitHub，而不是使用一个所有用户共享的单一机器人令牌。对于有 SOC 2、GDPR 或 HIPAA 等合规要求的部署，身份标识作用域为审计员提供了他们期望的数据隔离边界：每个调用者的线程和记忆是隔离的，并且 runtime.identity 为你提供了谁触发了每次运行的审计跟踪。

将身份标识添加到先前没有身份标识的项目中，不会删除现有的线程或记忆。在启用身份标识之前创建的线程在智能体作用域下仍可访问。新的线程则会根据你的声明，按执行者（或租户）划分作用域。要迁移旧数据，请导出数据并在新的作用域规则下重新创建线程。

理解三个核心概念

在编写任何身份标识配置之前，请先学习这三个概念：

概念	简单含义	示例
执行者	本次运行所代表的人或服务	`user_123`、一个 GitHub 登录名、一个访客 ID
租户（可选）	当一个部署服务多个组织时，用于区分客户或组织的边界	`acme`、一个 Slack 工作区
入口	运行时如何得知本次请求的调用者身份	你的后端发送身份标识头，或者浏览器发送一个已验证的登录令牌

一些重要的澄清：

执行者不是智能体。它是本次运行所代表的调用者。
租户不是 LangSmith 工作区。单租户智能体没有租户。
失败关闭意味着运行时会拒绝任何缺少必需的执行者或租户的请求。它永远不会回退到共享的记忆或线程。

根据执行者（以及可选的租户），管理型深度智能体得出三种结果：

线程：谁可以打开或恢复一个对话。
记忆：本次运行可以看到哪个持久化的上下文中心切片。
凭据：智能体在下游工具调用中使用谁的令牌（已登录用户，还是一个共享的智能体令牌）。

选择一个预设

预设编码了常见的产品形态，这样你就不必在第一天就自己设计作用域规则。从这里开始，然后仅覆盖不同的部分。预设表使用以下作用域值：

值	含义
`actor`	对已登录的人（或服务执行者）私有
`tenant`	在一个客户组织内共享，与其他组织隔离
`channel`	由同一频道（例如 Slack）中的所有人共享
`agent`	由整个部署共享
(未设置) / `none`	在此轴上不设作用域

凭据通常是团队首先考虑的事情：

actor：下游调用可以代表已登录用户操作（例如，以 Alice 的身份调用 GitHub）。
agent`：下游调用为每个人使用一个共享的机器人或服务令牌。

管理型深度智能体开箱即用地提供五种产品形态，覆盖了最常见的部署模式。根据你的产品形态选择一个预设：

预设	使用场景…	线程	记忆	凭据
`private-assistant`	每个人拥有一个带独立历史和记忆的私有助手	`actor`	`actor`	`actor`
`multi-tenant-saas`	一个部署服务多个客户组织；用户共享组织数据，但不跨组织共享	`actor`	`tenant`	`agent`
`shared-bot`	Slack/Discord 风格的机器人，频道中的所有人共享同一个线程	`channel`	`actor`	`agent`
`internal-tool`	公司内部工具：单个组织，按用户私有线程	`actor`	`actor`	`agent`
`service`	仅通过 Cron/网络钩子运行的智能体，没有人类调用者，共享记忆	(未设置)	`agent`	`agent`

除 multi-tenant-saas 设置 tenancy: "multi" 外，所有预设默认为 trusted_backend 入口和 tenancy: "single"。

如何快速选择：

一个对话对应一个人类，且不能看到其他人的数据 → private-assistant
带有客户组织的 SaaS → multi-tenant-saas
共享频道的机器人 → shared-bot
公司内部工具 → internal-tool
没有用户的定时器或网络钩子 → service

添加身份标识声明

在你的智能体入口旁边创建 identity.py 或 identity.ts 文件，并导出一个名为 identity 的变量。大多数项目可以从一行预设代码开始：

from managed_deepagents import define_identity

identity = define_identity.preset("private-assistant")

import { defineIdentity } from "managed-deepagents";

export const identity = defineIdentity.preset("private-assistant");

这会展开成如下完整的契约：

from managed_deepagents import define_identity

identity = define_identity(
    ingress={"http": "trusted_backend"},
    tenancy="single",
    scoping={
        "threads": "actor",
        "memory": "actor",
        "credentials": "actor",
    },
)

import { defineIdentity } from "managed-deepagents";

export const identity = defineIdentity({
  ingress: { http: "trusted_backend" },
  tenancy: "single",
  scoping: {
    threads: "actor",
    memory: "actor",
    credentials: "actor",
  },
});

当你希望每个字段都可见时，或者当你正在组装一个与预设不匹配的配置时，可以使用完整形式。你也可以从一个预设开始，然后只覆盖那些不同的字段。同一个 define_identity / defineIdentity 对象既可以用作工厂（完整形式），也可以用作预设选择器（.preset() 方法）。关于完整的项目布局，请参阅 CLI 项目文件参考。当存在身份标识时，mda 会生成自定义的认证处理器，将其注入到编译后的 LangGraph 应用中，然后才启用保留的身份标识头和令牌验证。

入口：识别调用者

入口是运行时用来识别每个请求的执行者（和租户）的机制。选择一个 HTTP 模式：trusted_backend 或 validated_token。

受信任的后端（推荐默认）

你自己的 API 认证用户（会话、OAuth 或类似方式），然后使用共享的入口密钥和保留的身份标识头代理 LangGraph 请求。浏览器永远不会将密钥或原始身份提供商（IdP）令牌发送给管理型深度智能体。这是所有预设的默认入口，也是当你的智能体前已有后端时的推荐选择。关于更广泛的 LangGraph 认证模型，请参阅为你的服务器添加认证。必需的请求头（不区分大小写）：

请求头	是否必需	用途
`X-MDA-Ingress-Secret`	是	来自 `MDA_INGRESS_SECRET` 的共享密钥
`X-MDA-Actor-Id`	是	本次运行的执行者 ID
`X-MDA-Tenant-Id`	当 `tenancy: "multi"` 时	本次运行的租户 ID

使用一个默认为受信任后端入口的预设：

from managed_deepagents import define_identity

identity = define_identity.preset("internal-tool")

import { defineIdentity } from "managed-deepagents";

export const identity = defineIdentity.preset("internal-tool");

将 MDA_INGRESS_SECRET 放在 .env 文件中供 mda dev 使用，并作为 mda deploy 的托管部署密钥。在生产环境中，你的后端验证用户身份，然后在代理智能体流量时附加身份标识头（X-MDA-Ingress-Secret、X-MDA-Actor-Id，以及在适用时附加 X-MDA-Tenant-Id）。后端代理示例形状（伪代码）：

// 你的应用认证用户之后
await fetch(`${deploymentUrl}/threads/${threadId}/runs`, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "X-MDA-Ingress-Secret": process.env.MDA_INGRESS_SECRET!,
    "X-MDA-Actor-Id": authenticatedUser.id,
    // "X-MDA-Tenant-Id": org.id, // 仅当 tenancy 为 "multi" 时
  },
  body: JSON.stringify(runBody),
});

切勿提交入口密钥或身份提供商凭据。仅从受信任的后端代理发送 MDA_INGRESS_SECRET，永远不要从浏览器发送。

已验证令牌（浏览器直连）

当浏览器直接与部署通信，并且你不想使用一个断言执行者头的代理时，使用此模式。客户端发送 Authorization: Bearer <token>。管理型深度智能体在服务器端验证令牌，并将声明（令牌内的字段，如用户 ID）映射到 runtime.identity。验证可以使用：

JWKS：你的身份提供商发布的公钥，以便运行时可以验证签名的 JWT。
OIDC 发现：指向这些密钥的标准元数据。
不透明内省：调用身份提供商以询问一个非 JWT 令牌是否仍然有效。
访客令牌：由管理型深度智能体为匿名访客签名的短期令牌。

覆盖预设以启用已验证令牌入口。以下示例将 Supabase 登录与可选的访客访问相结合：

from managed_deepagents import define_identity, providers

identity = define_identity.preset(
    "internal-tool",
    {
        "ingress": {
            "http": {
                "mode": "validated_token",
                "providers": [
                    providers.supabase(project_ref="your-project-ref"),
                    providers.guest(ttl="24h", actor_prefix="guest:"),
                ],
            }
        }
    },
)

import { defineIdentity, providers } from "managed-deepagents";

export const identity = defineIdentity.preset("internal-tool", {
  ingress: {
    http: {
      mode: "validated_token",
      providers: [
        providers.supabase({ projectRef: "your-project-ref" }),
        providers.guest({ ttl: "24h", actorPrefix: "guest:" }),
      ],
    },
  },
});

在 validated_token 模式下，你的前端使用你配置的同一个身份提供商让用户登录，读取访问令牌（或在适用时读取 ID 令牌），并将其作为 Authorization: Bearer <token> 传递给 LangGraph 客户端。不要将刷新令牌或客户端密钥发送到部署端。当你配置了多个提供商时，请为每个条目指定一个唯一的 id。运行时根据令牌的 iss（签发者）路由 JWT 提供商，当签发者与任何已配置的提供商不匹配时返回 401。关于特定提供商的选项和客户端示例，请参阅提供商设置指南。要让匿名访客在没有外部身份提供商的情况下使用智能体，请将访客令牌配置为唯一的提供商。每个访客都会获得一个短期的、由管理型深度智能体签名的令牌和一个独特的访客执行者，因此 private-assistant 预设仍然会按访客划定线程和记忆的作用域。

from managed_deepagents import define_identity, providers

identity = define_identity.preset(
    "private-assistant",
    {
        "ingress": {
            "http": {
                "mode": "validated_token",
                "providers": [
                    providers.guest(ttl="24h", actor_prefix="guest:"),
                ],
            }
        }
    },
)

import { defineIdentity, providers } from "managed-deepagents";

export const identity = defineIdentity.preset("private-assistant", {
  ingress: {
    http: {
      mode: "validated_token",
      providers: [providers.guest({ ttl: "24h", actorPrefix: "guest:" })],
    },
  },
});

当配置了访客提供商时，部署会暴露一个公共的 POST /identity/guest 路由来签发访客令牌。客户端调用它一次，然后在后续请求中发送返回的令牌作为 Authorization: Bearer <token>。响应体为 {"token": "<token>"}。

USER_TOKEN=$(curl -s -X POST "$DEPLOYMENT_URL/identity/guest" \
  -H "Content-Type: application/json" | python -c 'import sys, json; print(json.load(sys.stdin)["token"])')

密钥检查清单

密钥	管理型深度智能体如何使用它
`MDA_INGRESS_SECRET`	你的后端在 `X-MDA-Ingress-Secret` 中发送的共享密钥。运行时在信任 `X-MDA-Actor-Id` 和 `X-MDA-Tenant-Id` 之前会检查它。
`MDA_GUEST_SIGNING_KEY`	用于在 `POST /identity/guest` 签发访客令牌，并在后续请求中验证它们的密钥。

将本地值放在 .env 文件中。mda deploy 会将非保留的 .env 值作为托管部署密钥转发。特定于提供商的密钥（例如 Supabase 内省）在提供商设置指南中列出。

切勿提交入口密钥、访客签名密钥或身份提供商凭据。仅从受信任的后端代理发送 MDA_INGRESS_SECRET，永远不要从浏览器发送。

在工具和中间件中使用 `runtime.identity`

当声明了身份标识后，编写的工具和中间件会接收到一个从受信任的认证结果构建的冻结的 runtime.identity 对象。客户端提供的、可伪造的身份标识键会从 configurable 中剥离。身份标识对象如下所示：

runtime.identity = {
  actor: { type: "user" | "service", id: string, email?: string },
  tenant?: { id: string },
  source: {
    provider: "http" | "slack" | "schedule" | "cli" | "studio",
    threadId?: string,
  },
  claims?: Record<string, unknown>, // 在 validated_token 入口中填充
};

将注入的 runtime 参数注解为 ManagedDeepAgentRuntime，这样你就可以类型化地访问 identity（以及可选的 credentials）。当工具或中间件钩子需要知道谁触发了运行时（例如用于个性化、审计日志或基于已验证声明的分支逻辑），而不信任请求体中的任何内容时，可以使用它。

from langchain.tools import tool
from managed_deepagents import ManagedDeepAgentRuntime


@tool
def whoami(runtime: ManagedDeepAgentRuntime) -> str:
    """返回本次运行已认证的执行者ID。"""
    identity = runtime.identity
    if not identity:
        return "本次运行没有已认证的调用者。"
    return f"以 {identity['actor']['id']} 身份登录"

import { z } from "zod";
import { tool } from "langchain";
import type { ManagedDeepAgentRuntime } from "managed-deepagents";

export const whoami = tool(
  async (_input, runtime: ManagedDeepAgentRuntime) => {
    const identity = runtime.identity;
    if (!identity) {
      return "本次运行没有已认证的调用者。";
    }
    return `以 ${identity.actor.id} 身份登录`;
  },
  {
    name: "whoami",
    description: "返回本次运行已认证的执行者ID。",
    schema: z.object({}),
  },
);

相同的类型也可用于中间件钩子：

from langchain.agents.middleware import AgentState, before_model
from managed_deepagents import ManagedDeepAgentRuntime


def audit_middleware():
    @before_model
    def audit(state: AgentState, runtime: ManagedDeepAgentRuntime) -> dict | None:
        user = runtime.identity["actor"]["id"] if runtime.identity else "anonymous"
        print(f"[审计] {user} 模型调用，包含 {len(state['messages'])} 条消息")
        return None

    return audit

import { createMiddleware } from "langchain";
import type { ManagedDeepAgentRuntime } from "managed-deepagents";

export function auditMiddleware() {
  return createMiddleware({
    name: "audit",
    beforeModel: (state, runtime: ManagedDeepAgentRuntime) => {
      const user = runtime.identity?.actor.id ?? "anonymous";
      console.log(
        `[审计] ${user} 模型调用，包含 ${state.messages.length} 条消息`
      );
      return undefined;
    },
  });
}

对于执行者或租户 ID，优先使用 runtime.identity 而不是客户端提供的可配置键。对于其他每次运行的值（如功能标志），请使用普通的 LangChain 运行时上下文。

自定义作用域

预设覆盖了常见情况。若要自定义，请显式设置 scoping：

轴	值	含义
`threads`	`actor`, `channel`, `tenant`	谁可以打开或恢复对话
`memory`	`actor`, `tenant`, `agent`, `none`	哪个上下文中心记忆切片在本次运行中被重新挂载
`credentials`	`agent`, `actor`, `none`, `custom`	下游调用使用谁的凭据

如果 tenancy 为 "single"，则不要将任何作用域轴设置为 "tenant"，因为没有租户可以划分作用域。如果请求缺少作用域所需的执行者或租户 ID，管理型深度智能体会以 403 拒绝它，而不是回退到共享数据。关于记忆路径在每种作用域下如何重新挂载，请参阅使用身份标识划分记忆作用域。

自定义下游凭据

当你的应用可以安全地为下游目标获取每个执行者的凭据时，使用 scoping.credentials: "custom"。提供一个 resolve 函数；工具随后调用 runtime.credentials.for(target) 来获取该请求的头信息。解析后的凭据保存在内存中，永远不会写入线程状态或跟踪记录。

证明调用者身份的令牌不自动成为下游 API 的凭据。例如，一个 Supabase 访问令牌让管理型深度智能体可以识别调用者，但它不是 GitHub API 令牌。你的后端或凭据服务必须持有（并在需要时刷新）调用者单独授权的 GitHub 凭据。

以下代码形状允许用户通过 Supabase 登录，并以他们自己的身份打开 GitHub 拉取请求。在用户单独授权 GitHub 之后，你的应用将 GitHub 授权存储在以 Supabase 用户 ID 为键的位置。getGitHubAccessToken 是应用程序代码：它在你的服务器端凭据存储中查找并刷新该授权。

identity.ts

import { defineIdentity, providers } from "managed-deepagents";
import { getGitHubAccessToken } from "./github-credentials.js";

export const identity = defineIdentity({
  ingress: {
    http: {
      mode: "validated_token",
      providers: [providers.supabase({ projectRef: "your-project-ref" })],
    },
  },
  tenancy: "single",
  scoping: {
    threads: "actor",
    memory: "actor",
    credentials: "custom",
  },
  credentials: {
    async resolve({ identity, target }) {
      if (target.name !== "github") {
        throw new Error(`未为 ${target.name} 配置凭据。`);
      }

      const credential = await getGitHubAccessToken(identity.actor.id);
      if (!credential) {
        throw new Error("使用 GitHub 工具前请先连接 GitHub。");
      }

      return {
        headers: { Authorization: `Bearer ${credential.token}` },
        expiresAt: credential.expiresAt.toISOString(),
      };
    },
  },
});

在 GitHub 工具中，通过 await runtime.credentials.for({ kind: "connection", name: "github", intent: "write" }) 请求头信息，并将其传递给你的 GitHub 客户端。要将 LangSmith 功能暴露给浏览器或其他不受信任的调用者，请添加一个 LangSmith 连接器。它需要身份标识，以便功能路由可以在调用 LangSmith 服务器端之前解析调用者并证明所有权。

提供商设置指南

这些指南涵盖了用于已验证令牌入口的内置提供商。使用一个提供商，或者像该部分示例中那样组合它们。

访客令牌
Supabase
GitHub

匿名访客无需登录即可获得一个短期的、按执行者划分作用域的会话。管理型深度智能体使用 MDA_GUEST_SIGNING_KEY（HS256）签署访客令牌，并将 sub 映射为执行者。

选项	是否必需	描述
`ttl`	否	令牌有效期（例如 `"24h"`）
`actorPrefix` / `actor_prefix`	否	生成的执行者 ID 的前缀（例如 `"guest:"`）

访客通常与另一个身份提供商结合使用，如已验证令牌示例中所示。在 .env 文件中设置 MDA_GUEST_SIGNING_KEY 供 mda dev 使用，并作为 mda deploy 的托管部署密钥。

领取访客令牌

启用访客签发后，部署会暴露 POST /identity/guest。发送一个空的 POST 请求，设置 Content-Type: application/json。如果部署需要公共应用密钥（LANGGRAPH_AUTH_SECRET），还需发送 X-Auth-Key。

curl -X POST "$LANGGRAPH_API_URL/identity/guest" \
  -H "Content-Type: application/json"

成功时：

{
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
}

使用访客令牌

以你发送身份提供商访问令牌的方式发送该令牌：

Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

import { Client } from "@langchain/langgraph-sdk";

const response = await fetch(`${deploymentUrl}/identity/guest`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
});
const { token } = (await response.json()) as { token: string };

const client = new Client({
  apiUrl: deploymentUrl,
  defaultHeaders: { Authorization: `Bearer ${token}` },
});

import httpx
from langgraph_sdk import get_client

response = httpx.post(f"{deployment_url}/identity/guest")
response.raise_for_status()
token = response.json()["token"]

client = get_client(
    url=deployment_url,
    headers={"Authorization": f"Bearer {token}"},
)

对于浏览器应用，通过你自己的后端代理访客签发，并将令牌存储在 httpOnly cookie 中。这样可以在直到 exp 之前跨页面加载保持相同的访客执行者，并允许你在调用部署之前处理速率限制。

当当前令牌过期或丢失时，请重新领取令牌。在令牌仍然有效时，请重复使用它，以便访客在令牌有效期内保持相同的执行者 ID、线程和记忆作用域。

默认使用 JWKS（非对称 JWT）。将 sub 映射为执行者。仅传递 projectRef 或 url 中的一个。

选项	是否必需	描述
`projectRef` / `project_ref`	`projectRef` 或 `url` 二选一	`.supabase.co` 之前的子域名
`url`	`projectRef` 或 `url` 二选一	项目 URL 或自定义认证域
`introspect`	否	对于需要 `/auth/v1/user` 的遗留 HS256 项目设为 `true`

单独使用 providers.supabase(...)，或像已验证令牌示例中那样与访客结合使用。登录后，发送来自 @supabase/supabase-js 的 session.access_token。另请参阅 Supabase Auth 和 JWT 签名密钥。对于遗留内省，使用 introspect: true 并在部署上设置 SUPABASE_ANON_KEY。

通过 GET https://api.github.com/user 进行不透明令牌内省。将 login 映射为执行者，email 映射为邮箱。providers.github() 不接受任何选项。

from managed_deepagents import define_identity, providers

identity = define_identity.preset(
    "internal-tool",
    {
        "ingress": {
            "http": {
                "mode": "validated_token",
                "providers": [providers.github()],
            }
        }
    },
)

import { defineIdentity, providers } from "managed-deepagents";

export const identity = defineIdentity.preset("internal-tool", {
  ingress: {
    http: {
      mode: "validated_token",
      providers: [providers.github()],
    },
  },
});

完成 GitHub OAuth App 登录流程，然后发送用户访问令牌。不要将 OAuth 客户端密钥发送到部署端。另请参阅授权 OAuth 应用和获取已认证用户。对于生产环境，建议使用受信任的后端入口：将 GitHub 令牌保存在你的 API 上，并使用 X-MDA-Ingress-Secret + X-MDA-Actor-Id（例如 GitHub 的 login）进行代理。

测试与部署

使用 mda dev 在本地测试项目，然后使用 mda deploy 进行部署。在 LangSmith 中打开部署追踪，以检查模型调用、工具调用、错误和延迟情况。身份标识配置错误通常在本地 Studio 或首次认证请求期间表现为 401（认证）或 403（存储/线程作用域）。请确认存在匹配的密钥，并且受信任的后端代理附加了保留的头信息。

后续步骤

记忆

了解身份标识如何重新挂载按执行者或按租户划分的记忆。

自定义工具

从编写的工具中读取 runtime.identity。

评估

当声明了身份标识时，为 Harbor 任务提供 identity.json 测试固件。

计划任务

运行定时智能体，包括 service 预设形态。

LangSmith 连接器

将受限的 LangSmith 功能暴露给不受信任的调用者。

频道

通过 shared-bot 或 Connect-with-Slack 链接接收 Slack 事件。

工作原理

了解编译和部署如何将认证连接到运行时。

CLI 参考

查询 mda 中的项目文件和身份标识连接。

Connect these docs to Claude, VSCode, and more via MCP for real-time answers.

Edit this page on GitHub or file an issue.

Get started

Agent definition

Build and deploy

为管理型深度智能体添加身份标识

为什么身份标识对智能体至关重要

理解三个核心概念

选择一个预设

添加身份标识声明

入口：识别调用者

受信任的后端（推荐默认）

已验证令牌（浏览器直连）

密钥检查清单

在工具和中间件中使用 `runtime.identity`

自定义作用域

自定义下游凭据

提供商设置指南

领取访客令牌

使用访客令牌

测试与部署

后续步骤

记忆

自定义工具

评估

计划任务

LangSmith 连接器

频道

工作原理

CLI 参考

​为什么身份标识对智能体至关重要

​理解三个核心概念

​选择一个预设

​添加身份标识声明

​入口：识别调用者

​受信任的后端（推荐默认）

​已验证令牌（浏览器直连）

​密钥检查清单

​在工具和中间件中使用 runtime.identity

​自定义作用域

​自定义下游凭据

​提供商设置指南

​领取访客令牌

​使用访客令牌

​测试与部署

​后续步骤

记忆

自定义工具

评估

计划任务

LangSmith 连接器

频道

工作原理

CLI 参考

为什么身份标识对智能体至关重要

理解三个核心概念

选择一个预设

添加身份标识声明

入口：识别调用者

受信任的后端（推荐默认）

已验证令牌（浏览器直连）

密钥检查清单

在工具和中间件中使用 `runtime.identity`

自定义作用域

自定义下游凭据

提供商设置指南

领取访客令牌

使用访客令牌

测试与部署

后续步骤