沙箱挂载

把 S3 存储桶、GCS 存储桶、公共 Git 仓库和 Context Hub 仓库挂载进 LangSmith 沙箱。

沙箱挂载在创建沙箱时把外部数据源接入沙箱文件系统。当沙箱代码需要对对象存储桶、公共 Git 仓库或 Context Hub 仓库的直接文件访问、而又不想把数据复制进沙箱镜像时，使用挂载。

挂载通过 Python 中的 mount_config 或 TypeScript 中的 mountConfig 配置。SDK 把挂载规范发送给 LangSmith，并为提供商凭据组装所需的身份验证代理规则。

NOTE

沙箱挂载需要 Python 的 langsmith[sandbox]>=0.8.16 或 TypeScript 的 langsmith>=0.7.10。Context Hub 挂载需要 Python 的 langsmith[sandbox]>=0.11.0 或 TypeScript 的 langsmith>=0.8.11。

WARNING

当你使用静态 AWS 密钥或 GCP 服务账户时，在创建沙箱之前把云凭据存为 LangSmith 工作区机密。用 IAM 角色身份验证的 S3 挂载不需要存 AWS 访问密钥。不要把真实云凭据作为沙箱环境变量、命令参数或文件传入。

配置挂载路径

每个挂载都有一个 id、一个 type，以及一个 mount_path / mountPath。Bucket 和 Git 挂载必须在 /mnt/mounts 下使用绝对路径。Context Hub 挂载路径可以是系统目录之外的任何绝对路径，以便 agent 能从它已经预期的位置读取它的上下文。

使用描述已挂载来源的稳定路径：

来源	示例路径
S3 存储桶前缀	`/mnt/mounts/customer-data`
GCS 存储桶前缀	`/mnt/mounts/eval-datasets`
Git 仓库	`/mnt/mounts/repo`
Context Hub 仓库	`/memories`

挂载 ID 可以含 ASCII 字母、数字、下划线和连字符。不要在同一沙箱内重复使用一个 ID 或挂载路径。

挂载一个 S3 存储桶

S3 挂载需要 AWS 身份验证。当你的部署和 SDK 支持角色身份验证时，使用静态访问密钥或一个 IAM 角色。LangSmith UI 也支持角色设置。两种方法都把真实 AWS 凭据留在沙箱之外。

用静态访问密钥身份验证

SDK 从 aws_auth / awsAuth 创建一条 AWS 身份验证代理规则，使沙箱能访问该存储桶而无需看到真实访问密钥。

PythonTypeScript

python

from langsmith.sandbox import (
    SandboxClient,
    aws_auth,
    mount_config,
    s3_mount,
    workspace_secret,
)

client = SandboxClient()

mount_cfg = mount_config(
    auth=[
        aws_auth(
            access_key_id=workspace_secret("SANDBOX_AWS_ACCESS_KEY_ID"),
            secret_access_key=workspace_secret("SANDBOX_AWS_SECRET_ACCESS_KEY"),
        )
    ],
    mounts=[
        s3_mount(
            id="customer_data",
            mount_path="/mnt/mounts/customer-data",
            bucket="example-bucket",
            prefix="datasets/customer-data",
            region="us-east-1",
            path_style=False,
            read_only=True,
        )
    ],
)

with client.sandbox(name="s3-mount-sandbox", mount_config=mount_cfg) as sb:
    result = sb.run("ls /mnt/mounts/customer-data")
    print(result.stdout)

import {
  SandboxClient,
  awsAuth,
  mountConfig,
  s3Mount,
  workspaceSecret,
} from "langsmith/sandbox";

const client = new SandboxClient();

const mountCfg = mountConfig({
  auth: [
    awsAuth({
      accessKeyId: workspaceSecret("SANDBOX_AWS_ACCESS_KEY_ID"),
      secretAccessKey: workspaceSecret("SANDBOX_AWS_SECRET_ACCESS_KEY"),
    }),
  ],
  mounts: [
    s3Mount({
      id: "customer_data",
      mountPath: "/mnt/mounts/customer-data",
      bucket: "example-bucket",
      prefix: "datasets/customer-data",
      region: "us-east-1",
      pathStyle: false,
      readOnly: true,
    }),
  ],
});

const sandbox = await client.createSandbox({
  name: "s3-mount-sandbox",
  mountConfig: mountCfg,
});

try {
  const result = await sandbox.run("ls /mnt/mounts/customer-data");
  console.log(result.stdout);
} finally {
  await sandbox.delete();
}

用一个 IAM 角色身份验证

IAM 角色身份验证让 AWS 身份验证代理在你 AWS 账户中承担一个角色。S3 挂载使用与沙箱中其他受支持 AWS 请求相同的身份验证。LangSmith 获取并续期临时 AWS 凭据，因此你不需要在工作区机密中存或轮换访问密钥。

NOTE

这个选项要求你的 LangSmith 部署启用 AWS 代理角色身份验证。为 ECR 仓库启用 IAM 角色不会为身份验证代理启用它们。如果 AWS 身份验证选项中缺少 AWS IAM role，请改用静态访问密钥或联系你的 LangSmith 管理员。基于角色的 SDK 示例需要一个在 Python 中带 aws_auth(role_arn=...) 和 mount_config(proxy_config=...)、或在 TypeScript 中带 awsAuth({ roleArn }) 和 mountConfig({ proxyConfig }) 的发布版本。本页顶部列出的挂载版本并不确立对这些较新选项的支持。

你需要权限来配置客户 IAM 角色的信任和访问策略。一条 AWS 身份验证规则适用于沙箱的 AWS 请求，包括所有 S3 挂载。选择静态访问密钥或一个 IAM 角色之一；不要两者都配置。角色身份验证在创建时配置。要添加、移除、禁用或更改其角色，请新建一个沙箱。

LangSmith 主体也需要承担客户角色的权限。对于自托管部署，你的管理员配置那个权限和任何所需的角色标签。跨账户 S3 存储桶可能还需要一个允许客户角色的存储桶策略。

要配置该角色并创建沙箱：

打开 Sandboxes > Create sandbox，在 Mounts 部分添加一个 S3 bucket，并配置其存储桶、区域、前缀、挂载路径和只读设置。
进入 Network 部分，启用 AWS 身份验证，并选择 AWS IAM role。要在无挂载的情况下使用角色，跳过步骤 1 中的挂载配置。
在 IAM 角色的信任策略中使用 AWS role ARN 下方显示的两个值：
- Principal：这个 LangSmith 部署用来承担客户角色的确切 AWS 角色 ARN。使用显示的主体，而不是从另一个环境或从 ECR 仓库复制的 ARN。
- External ID：你当前的 LangSmith 工作区 UUID。LangSmith 在承担角色时提供这个值；你不需要选一个单独的 external ID。
展开 AWS role setup，选择 Copy trust policy，并把该策略应用到 AWS IAM 中的客户角色。它只允许带匹配 sts:ExternalId 的所示主体发起 sts:AssumeRole。
为沙箱所需的 AWS 服务和资源附加一个最小权限策略。对于已配置的 S3 挂载，Copy S3 permissions 提供一个起始策略。在附加它之前审阅它；LangSmith 不会自动应用它。
在 AWS role ARN 中输入客户角色的 ARN。这是你在账户中配置的那个角色，而非设置说明中显示的 LangSmith 主体。
选择 Create Sandbox，然后验证沙箱代码能读取已挂载路径，对可写挂载还能写入它。

生成的信任策略有这种结构。把占位符替换为表单中显示的主体和 external ID，或从表单复制已完成的策略：

json

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "<LANGSMITH_AWS_PROXY_PRINCIPAL_ARN>"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": {
          "sts:ExternalId": "<LANGSMITH_WORKSPACE_ID>"
        }
      }
    }
  ]
}

不要把主体替换为 * 或移除 external ID 条件。在 LangSmith 中输入客户角色 ARN 不会创建该角色或更新它的 AWS 策略。

限制 S3 访问

可选的 S3 权限示例根据挂载设置授予访问：

所有 S3 挂载：存储桶位置访问、前缀范围列表，以及对象读。
可写挂载：额外的对象写、删除和分片上传权限。
空前缀：遍及整个存储桶的对象访问。用一个前缀把访问限制到一个子树。

角色的有效 AWS 权限控制所有受支持的 AWS 代理请求。LangSmith 不会把一个通用 AWS 角色会话限制到已配置的挂载。把角色的 IAM 策略限制到所需的存储桶、前缀、操作和其他 AWS 资源。

WARNING

只读挂载会拒绝文件系统写入，但不阻塞角色允许的直接 S3 API 写入。用角色的 IAM 策略来强制只读 AWS 访问。

使用商用 AWS 角色和受支持的 AWS HTTPS 端点。S3 权限示例不含 KMS 权限；审阅你存储桶加密设置所需的权限。

在 SDK 中使用共享角色

一个共享的 AWS 代理角色既为 S3 挂载、也为受支持的应用请求身份验证，与上面 UI 设置一样。先配置信任和权限策略，然后把示例角色 ARN 和存储桶替换为你自己的值。

把同一个代理配置传给挂载助手和沙箱创建。挂载助手不会把它复制到挂载专属的身份验证中：

PythonTypeScript

python

from langsmith.sandbox import (
    SandboxClient,
    aws_auth,
    mount_config,
    proxy_config,
    s3_mount,
)

proxy_cfg = proxy_config(
    rules=[aws_auth(role_arn="arn:aws:iam::123456789012:role/LangSmithSandbox")]
)
mount_cfg = mount_config(
    proxy_config=proxy_cfg,
    mounts=[
        s3_mount(
            id="customer_data",
            mount_path="/mnt/mounts/customer-data",
            bucket="example-bucket",
            prefix="datasets/customer-data",
            region="us-east-1",
            read_only=True,
        )
    ],
)

client = SandboxClient()
sandbox = client.create_sandbox(
    name="shared-role-mount-sandbox",
    mount_config=mount_cfg,
    proxy_config=proxy_cfg,
)

import {
  SandboxClient,
  awsAuth,
  mountConfig,
  proxyConfig,
  s3Mount,
} from "langsmith/sandbox";

const proxyCfg = proxyConfig({
  rules: [
    awsAuth({ roleArn: "arn:aws:iam::123456789012:role/LangSmithSandbox" }),
  ],
});
const mountCfg = mountConfig({
  proxyConfig: proxyCfg,
  mounts: [
    s3Mount({
      id: "customer_data",
      mountPath: "/mnt/mounts/customer-data",
      bucket: "example-bucket",
      prefix: "datasets/customer-data",
      region: "us-east-1",
      readOnly: true,
    }),
  ],
});

const client = new SandboxClient();
const sandbox = await client.createSandbox({
  name: "shared-role-mount-sandbox",
  mountConfig: mountCfg,
  proxyConfig: proxyCfg,
});

共享规则保留其有效的 IAM 权限。本例中的只读挂载不会阻止角色允许的直接 S3 API 写入。共享代理身份验证对 S3 挂载受支持，而非 GCS 挂载；GCS 仍需显式挂载身份验证。

把一个角色限制到 S3 挂载作用域

挂载专属的角色身份验证会添加一个会话策略，把 AWS 访问限制到已配置的 S3 存储桶、前缀和只读设置。当沙箱 AWS 访问必须留在那些挂载作用域内时，使用这个 API 替代方案。客户角色仍需上面描述的信任和权限策略。

把角色传入 auth 以把它序列化为 mount_config.auth.aws.role_arn。不要同时也传入一个 AWS 代理规则：

PythonTypeScript

python

from langsmith.sandbox import SandboxClient, aws_auth, mount_config, s3_mount

mount_cfg = mount_config(
    auth=[aws_auth(role_arn="arn:aws:iam::123456789012:role/LangSmithSandbox")],
    mounts=[
        s3_mount(
            id="customer_data",
            mount_path="/mnt/mounts/customer-data",
            bucket="example-bucket",
            prefix="datasets/customer-data",
            region="us-east-1",
            read_only=True,
        )
    ],
)

client = SandboxClient()
sandbox = client.create_sandbox(
    name="mount-scoped-role-sandbox",
    mount_config=mount_cfg,
)

import { SandboxClient, awsAuth, mountConfig, s3Mount } from "langsmith/sandbox";

const mountCfg = mountConfig({
  auth: [
    awsAuth({ roleArn: "arn:aws:iam::123456789012:role/LangSmithSandbox" }),
  ],
  mounts: [
    s3Mount({
      id: "customer_data",
      mountPath: "/mnt/mounts/customer-data",
      bucket: "example-bucket",
      prefix: "datasets/customer-data",
      region: "us-east-1",
      readOnly: true,
    }),
  ],
});

const client = new SandboxClient();
const sandbox = await client.createSandbox({
  name: "mount-scoped-role-sandbox",
  mountConfig: mountCfg,
});

挂载专属的 mount_config.auth.aws API 接受 role_arn 或静态的 access_key_id 和 secret_access_key 对，但不同时接受两者。它不能与一个 AWS 代理规则组合。本页早前的静态密钥示例继续不变地工作。

续期凭据

LangSmith 在 AWS 请求需要时续期临时凭据，包括在沙箱停止并恢复之后。你不提供保存的 STS 令牌也不手动续期它。保持角色的信任和访问权限到位以持续访问。

如果续期暂时不可用，挂载只能使用缓存的凭据直到它们过期。一个授权拒绝或过期凭据会使已身份验证的 S3 请求失败；挂载不会回退到静态密钥。

挂载一个 GCS 存储桶

GCS 挂载需要 GCP 身份验证。OAuth 作用域由后端提供，从挂载本身派生：只读挂载得到 devstorage.read_only，可写挂载得到 devstorage.read_write。

因为单个 mount_config 解析为一个作用域，它的所有 GCS 挂载必须一致：在一个配置中混用只读和可写 GCS 挂载会被拒绝。全程使用可写挂载，或创建分开的沙箱。

PythonTypeScript

python

from langsmith.sandbox import (
    SandboxClient,
    gcp_auth,
    gcs_mount,
    mount_config,
    workspace_secret,
)

client = SandboxClient()

mount_cfg = mount_config(
    auth=[
        gcp_auth(
            service_account_json=workspace_secret(
                "SANDBOX_GCP_SERVICE_ACCOUNT_JSON"
            ),
        )
    ],
    mounts=[
        gcs_mount(
            id="eval_datasets",
            mount_path="/mnt/mounts/eval-datasets",
            bucket="example-bucket",
            prefix="datasets/evals",
            read_only=False,
        )
    ],
)

with client.sandbox(name="gcs-mount-sandbox", mount_config=mount_cfg) as sb:
    result = sb.run("ls /mnt/mounts/eval-datasets")
    print(result.stdout)

import {
  SandboxClient,
  gcpAuth,
  gcsMount,
  mountConfig,
  workspaceSecret,
} from "langsmith/sandbox";

const client = new SandboxClient();

const mountCfg = mountConfig({
  auth: [
    gcpAuth({
      serviceAccountJson: workspaceSecret("SANDBOX_GCP_SERVICE_ACCOUNT_JSON"),
    }),
  ],
  mounts: [
    gcsMount({
      id: "eval_datasets",
      mountPath: "/mnt/mounts/eval-datasets",
      bucket: "example-bucket",
      prefix: "datasets/evals",
      readOnly: false,
    }),
  ],
});

const sandbox = await client.createSandbox({
  name: "gcs-mount-sandbox",
  mountConfig: mountCfg,
});

try {
  const result = await sandbox.run("ls /mnt/mounts/eval-datasets");
  console.log(result.stdout);
} finally {
  await sandbox.delete();
}

挂载一个公共 Git 仓库

公共 Git 挂载不需要 AWS 或 GCP 身份验证。使用一个 HTTPS 远端 URL，并可选择固定一个分支或标签。

PythonTypeScript

python

from langsmith.sandbox import SandboxClient, git_mount, mount_config

client = SandboxClient()

mount_cfg = mount_config(
    mounts=[
        git_mount(
            id="repo",
            mount_path="/mnt/mounts/repo",
            remote_url="https://github.com/langchain-ai/langsmith-sdk.git",
            ref={"type": "branch", "name": "main"},
            refresh_interval_seconds=60,
        )
    ],
)

with client.sandbox(name="git-mount-sandbox", mount_config=mount_cfg) as sb:
    result = sb.run("ls /mnt/mounts/repo")
    print(result.stdout)

import { SandboxClient, gitMount, mountConfig } from "langsmith/sandbox";

const client = new SandboxClient();

const mountCfg = mountConfig({
  mounts: [
    gitMount({
      id: "repo",
      mountPath: "/mnt/mounts/repo",
      remoteUrl: "https://github.com/langchain-ai/langsmith-sdk.git",
      ref: { type: "branch", name: "main" },
      refreshIntervalSeconds: 60,
    }),
  ],
});

const sandbox = await client.createSandbox({
  name: "git-mount-sandbox",
  mountConfig: mountCfg,
});

try {
  const result = await sandbox.run("ls /mnt/mounts/repo");
  console.log(result.stdout);
} finally {
  await sandbox.delete();
}

私有 Git 仓库在远端需要代理管理的身份验证时，可使用底层的 proxy_config / proxyConfig 规则。尚无高层的私有 Git 身份验证助手。

挂载一个 Context Hub 仓库

一个 Context Hub 挂载把一个 agent 或技能仓库的最新 commit 镜像到沙箱文件系统。用它来给沙箱代码你的生产 agent 所拉取的相同指令、技能和工具，而无需把它们打包进沙箱镜像或在启动时复制进来。

把仓库标识为 owner/repo。对当前工作区中的仓库用 - 作为 owner，例如 -/my-agent。调用者的 API 密钥必须有对该仓库的读访问权。LangSmith 会对属于另一工作区私有的仓库拒绝沙箱创建，且不区分一个缺失的仓库与一个不可访问的仓库。Context Hub 挂载不需要 AWS 或 GCP 身份验证。

PythonTypeScript

python

from langsmith.sandbox import SandboxClient, context_hub_mount, mount_config

client = SandboxClient()

mount_cfg = mount_config(
    mounts=[
        context_hub_mount(
            id="memories",
            mount_path="/memories",
            repo="-/my-agent",
        )
    ],
)

with client.sandbox(
    name="context-hub-mount-sandbox", mount_config=mount_cfg
) as sb:
    result = sb.run("ls /memories")
    print(result.stdout)

import { SandboxClient, contextHubMount, mountConfig } from "langsmith/sandbox";

const client = new SandboxClient();

const mountCfg = mountConfig({
  mounts: [
    contextHubMount({
      id: "memories",
      mountPath: "/memories",
      repo: "-/my-agent",
    }),
  ],
});

const sandbox = await client.createSandbox({
  name: "context-hub-mount-sandbox",
  mountConfig: mountCfg,
});

try {
  const result = await sandbox.run("ls /memories");
  console.log(result.stdout);
} finally {
  await sandbox.delete();
}

该挂载包含仓库最新 commit 的扁平文件树。从另一个 agent 或技能仓库链接过来的文件，会出现在父仓库引用它的那个路径上，因此一个已挂载的 agent 也会携带它所组合的技能。有关组合仓库的更多信息，参阅用 SDK 管理上下文。

随变化读取一个仓库

Context Hub 挂载是只读的，且同步是单向的。在沙箱内挂载路径下写入的文件永不被推回仓库，下一次刷新会覆盖它们。把沙箱输出写到挂载之外的路径，并在它属于仓库时用 Context Hub SDK 推送它。

LangSmith 在沙箱的整个生命周期内保持挂载同步。新 commit 大约在 30 秒内到达一个运行中的沙箱。把那个节奏当作尽力而为而非新鲜度保证。一次刷新会一次性替换整棵树，因此读者会看到要么先前的 commit 要么新的，绝不会是混合。

一个挂载始终跟踪最新 commit。要读一个固定版本，用 Context Hub SDK 拉取你想要的 commit 或环境标签，而非挂载该仓库。

传入 initial_pull_only / initialPullOnly 以在启动时同步一次，然后停止轮询：

PythonTypeScript

python

context_hub_mount(
    id="memories",
    mount_path="/memories",
    repo="-/my-agent",
    initial_pull_only=True,
)

contextHubMount({
  id: "memories",
  mountPath: "/memories",
  repo: "-/my-agent",
  initialPullOnly: true,
});

对那些必须从头到尾读一个 commit 的运行使用单次拉取，例如你把结果与 agent 某个特定版本做比较的评估。

处理启动与失败

挂载目录在沙箱就绪时就存在，但其下的读会阻塞直到第一个 commit 树到达。在启动时立即读挂载的代码会等待初始同步，而非看到一个空目录。

LangSmith 会重试失败的刷新并继续提供它发布的最后一个 commit，因此一个暂态错误不会清空一个正常工作的挂载。两种情况会浮现到沙箱代码：

一个被拒绝的请求：读会以 EIO 失败。在沙箱启动之后撤销调用者对该仓库的访问，会拒绝后续的拉取，因为 LangSmith 在每次拉取时重新检查访问权。
一个超出同步限制的仓库：挂载不提供任何树。一个已同步的 commit 最多可持有 2,500 个文件和 25 MiB 的文件内容，计算仓库链接的一切。

组合挂载

一个沙箱可以挂载多个来源，包括一个 Context Hub 仓库连同 bucket 和 Git 挂载。构建一个含所有挂载规范的 mount_config / mountConfig，并为那些规范使用的每个 bucket 提供商包含提供商身份验证。

PythonTypeScript

python

from langsmith.sandbox import (
    aws_auth,
    git_mount,
    gcp_auth,
    gcs_mount,
    mount_config,
    s3_mount,
    workspace_secret,
)

mount_cfg = mount_config(
    auth=[
        aws_auth(
            access_key_id=workspace_secret("SANDBOX_AWS_ACCESS_KEY_ID"),
            secret_access_key=workspace_secret("SANDBOX_AWS_SECRET_ACCESS_KEY"),
        ),
        gcp_auth(
            service_account_json=workspace_secret(
                "SANDBOX_GCP_SERVICE_ACCOUNT_JSON"
            ),
        ),
    ],
    mounts=[
        s3_mount(
            id="s3_data",
            mount_path="/mnt/mounts/s3-data",
            bucket="example-s3-bucket",
        ),
        gcs_mount(
            id="gcs_data",
            mount_path="/mnt/mounts/gcs-data",
            bucket="example-gcs-bucket",
        ),
        git_mount(
            id="repo",
            mount_path="/mnt/mounts/repo",
            remote_url="https://github.com/langchain-ai/langsmith-sdk.git",
        ),
    ],
)

import {
  awsAuth,
  gitMount,
  gcpAuth,
  gcsMount,
  mountConfig,
  s3Mount,
  workspaceSecret,
} from "langsmith/sandbox";

const mountCfg = mountConfig({
  auth: [
    awsAuth({
      accessKeyId: workspaceSecret("SANDBOX_AWS_ACCESS_KEY_ID"),
      secretAccessKey: workspaceSecret("SANDBOX_AWS_SECRET_ACCESS_KEY"),
    }),
    gcpAuth({
      serviceAccountJson: workspaceSecret("SANDBOX_GCP_SERVICE_ACCOUNT_JSON"),
    }),
  ],
  mounts: [
    s3Mount({
      id: "s3_data",
      mountPath: "/mnt/mounts/s3-data",
      bucket: "example-s3-bucket",
    }),
    gcsMount({
      id: "gcs_data",
      mountPath: "/mnt/mounts/gcs-data",
      bucket: "example-gcs-bucket",
    }),
    gitMount({
      id: "repo",
      mountPath: "/mnt/mounts/repo",
      remoteUrl: "https://github.com/langchain-ai/langsmith-sdk.git",
    }),
  ],
});

缓存 bucket 挂载

S3 和 GCS 挂载支持可选的缓存设置。缓存设置调优 bucket 挂载所用的本地 VFS 缓存；bucket 仍是事实源。用缓存设置控制本地磁盘使用和回写时机，而非作为一个单独的持久层。缓存设置不适用于 Git 挂载。

字段	描述
`max_size_bytes`	本地挂载缓存的可选最大大小（字节）。设一个正值以加一个显式上限；省略它以保留运行时默认。
`writeback_seconds`	缓存写入被回写到 bucket 之前的可选延迟（秒）。默认为 `0`。较低的值使写入更早对 bucket 可见；较高的值可为重写相同文件的工作负载减少写流量。

对于只读数据集挂载，仅当你需要一个特定的本地缓存上限时才配置 max_size_bytes。对于可写挂载，当另一个进程需要在沙箱写入后不久从 S3 或 GCS 读取对象时，保持 writeback_seconds 较低。

PythonTypeScript

python

s3_mount(
    id="customer_data",
    mount_path="/mnt/mounts/customer-data",
    bucket="example-bucket",
    cache={
        "max_size_bytes": 2 * 1024**3,
        "writeback_seconds": 5,
    },
)

s3Mount({
  id: "customer_data",
  mountPath: "/mnt/mounts/customer-data",
  bucket: "example-bucket",
  cache: {
    max_size_bytes: 2 * 1024 ** 3,
    writeback_seconds: 5,
  },
});

同样的缓存设置可用于 GCS 挂载：

PythonTypeScript

python

gcs_mount(
    id="eval_datasets",
    mount_path="/mnt/mounts/eval-datasets",
    bucket="example-bucket",
    cache={
        "max_size_bytes": 2 * 1024**3,
        "writeback_seconds": 5,
    },
)

gcsMount({
  id: "eval_datasets",
  mountPath: "/mnt/mounts/eval-datasets",
  bucket: "example-bucket",
  cache: {
    max_size_bytes: 2 * 1024 ** 3,
    writeback_seconds: 5,
  },
});

限制

挂载在沙箱创建时接入。要更改挂载，新建一个沙箱。
在一个沙箱的一个身份验证界面中配置每个云提供商的凭据。如果挂载身份验证提供了 AWS 或 GCP 凭据，就不要为同一提供商再加一条身份验证代理规则。
Git ref 可以省略或设为一个分支或标签。不支持 commit ref。
Git 挂载不支持 read_only / readOnly 或缓存设置。
Context Hub 挂载总是只读，且不支持缓存设置。
Context Hub 挂载接受 agent 和技能仓库。LangSmith 会拒绝其他仓库类型和无 commit 的仓库。
一个 Context Hub 挂载路径不能是文件系统根，也不能位于系统目录（如 /etc、/usr 或 /var）之中或之下。
恢复一个沙箱会在其配置路径重新连接每个 Context Hub 挂载。一个恢复的进程若在挂载内持有打开的文件或工作目录，必须重新打开它。

数据集

创建数据集

运行评估

评估技术

定义评估目标

打分方法

实验配置

多模态评估

分析实验结果

微调

教程

常见数据类型

评估器类型

UI

SDK

框架与集成

改进评估器

反馈

追踪设置

集成

手动埋点

配置与故障排除

项目与环境设置

高级追踪技术

数据与隐私

故障排除指南

查看与管理追踪

批量导出追踪数据

轨迹视图

数据类型参考

监控与告警

在线评估器

自动化

开发你的应用

设置依赖

持久化

能力

助手

运行

并发消息处理

如何构建

鉴权与访问控制

自定义鉴权教程

服务器定制

静态加密

替换内置后端

扩展 HTTP 服务器

请求头与日志

部署指南

参考

配置

参考

提示词

创建与管理提示词

连接模型

上下文中枢

教程

全栈 Web 应用

Agent Server API

控制平面 API

计费与用量

参考

按云服务商起步

用 Terraform 部署

AWS

GCP

Azure

安装实例

配置实例

连接外部服务

平台鉴权与访问控制

管理实例

自托管可观测性

混合部署

脚本

参考

组织