> ## Documentation Index
> Fetch the complete documentation index at: https://cndoc-langchain.site/llms.txt
> Use this file to discover all available pages before exploring further.

# 防护栏

> 为您的代理实施安全检查和内容过滤

防护栏通过在代理执行的关键点验证和过滤内容，帮助您构建安全、合规的AI应用程序。它们可以检测敏感信息、执行内容策略、验证输出，并在问题发生前防止不安全的行为。

常见用例包括：

* 防止个人身份信息泄露
* 检测和阻止提示注入攻击
* 阻止不当或有害内容
* 执行业务规则和合规要求
* 验证输出质量和准确性

您可以使用[中间件](/oss/javascript/langchain/middleware)在战略点拦截执行来实现防护栏——在代理开始前、完成后，或围绕模型和工具调用。

<div style={{ display: "flex", justifyContent: "center" }}>
  <img src="https://mintcdn.com/other-405835d4/3NQVGWwcrOYcKZbP/oss/images/middleware_final.png?fit=max&auto=format&n=3NQVGWwcrOYcKZbP&q=85&s=4c4db62fcf650935ce6703625c5aa548" alt="中间件流程图" className="rounded-lg" width="500" height="560" data-path="oss/images/middleware_final.png" />
</div>

防护栏可以通过两种互补的方法来实现：

<CardGroup cols={2}>
  <Card title="确定性防护栏" icon="list-check">
    使用基于规则的逻辑，如正则表达式模式、关键词匹配或显式检查。快速、可预测且经济高效，但可能遗漏细微的违规行为。
  </Card>

  <Card title="基于模型的防护栏" icon="brain">
    使用LLM或分类器通过语义理解评估内容。能捕捉规则遗漏的微妙问题，但速度较慢且成本更高。
  </Card>
</CardGroup>

LangChain提供了内置防护栏（例如，[PII检测](#pii-detection)、[Human in the Loop](#human-in-the-loop)）以及一个灵活的中间件系统，用于使用任一方法构建自定义防护栏。

## 内置防护栏

### PII检测

LangChain提供内置中间件，用于检测和处理对话中的个人身份信息（PII）。此中间件可以检测常见的PII类型，如电子邮件、信用卡、IP地址等。

PII检测中间件对于以下情况很有帮助：具有合规要求的医疗保健和金融应用程序、需要清理日志的客户服务代理，以及通常任何处理敏感用户数据的应用程序。

PII中间件支持多种处理检测到的PII的策略：

| 策略       | 描述                          | 示例                    |
| -------- | --------------------------- | --------------------- |
| `redact` | 替换为 `[REDACTED_{PII_TYPE}]` | `[REDACTED_EMAIL]`    |
| `mask`   | 部分遮蔽（例如，最后4位数字）             | `****-****-****-1234` |
| `hash`   | 替换为确定性哈希值                   | `a8f5f167...`         |
| `block`  | 检测到时引发异常                    | 抛出错误                  |

```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { createAgent, piiRedactionMiddleware } from "langchain";

const agent = createAgent({
  model: "gpt-5.4",
  tools: [customerServiceTool, emailTool],
  middleware: [
    // 在发送到模型之前，对用户输入中的电子邮件进行脱敏
    piiRedactionMiddleware({
      piiType: "email",
      strategy: "redact",
      applyToInput: true,
    }),
    // 对用户输入中的信用卡进行遮蔽
    piiRedactionMiddleware({
      piiType: "credit_card",
      strategy: "mask",
      applyToInput: true,
    }),
    // 阻止API密钥 - 检测到时引发错误
    piiRedactionMiddleware({
      piiType: "api_key",
      detector: /sk-[a-zA-Z0-9]{32}/,
      strategy: "block",
      applyToInput: true,
    }),
  ],
});

// 当用户提供PII时，它将根据策略进行处理
const result = await agent.invoke({
  messages: [
    {
      role: "user",
      content: "我的邮箱是john.doe@example.com，卡号是5105-1051-0510-5100",
    },
  ],
});
```

<Accordion title="内置PII类型和配置">
  **内置PII类型：**

  * `email` - 电子邮件地址
  * `credit_card` - 信用卡号（Luhn验证）
  * `ip` - IP地址
  * `mac_address` - MAC地址
  * `url` - URL

  **配置选项：**

  | 参数                   | 描述                                                  | 默认值               |
  | -------------------- | --------------------------------------------------- | ----------------- |
  | `piiType`            | 要检测的PII类型（内置或自定义）                                   | 必需                |
  | `strategy`           | 如何处理检测到的PII（`"block"`、`"redact"`、`"mask"`、`"hash"`） | `"redact"`        |
  | `detector`           | 自定义检测器正则表达式模式                                       | `undefined`（使用内置） |
  | `applyToInput`       | 在模型调用前检查用户消息                                        | `true`            |
  | `applyToOutput`      | 在模型调用后检查AI消息                                        | `false`           |
  | `applyToToolResults` | 在执行后检查工具结果消息                                        | `false`           |
</Accordion>

有关PII检测功能的完整详情，请参阅[中间件文档](/oss/javascript/langchain/middleware#pii-detection)。

### Human in the Loop

LangChain提供内置中间件，用于在执行敏感操作前要求人工批准。这是高风险决策最有效的防护栏之一。

Human in the Loop中间件对于以下情况很有帮助：金融交易和转账、删除或修改生产数据、向外部方发送通信，以及任何具有重大业务影响的操作。

```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { createAgent, humanInTheLoopMiddleware } from "langchain";
import { MemorySaver, Command } from "@langchain/langgraph";

const agent = createAgent({
  model: "gpt-5.4",
  tools: [searchTool, sendEmailTool, deleteDatabaseTool],
  middleware: [
    humanInTheLoopMiddleware({
      interruptOn: {
        // 敏感操作需要批准
        send_email: { allowAccept: true, allowEdit: true, allowRespond: true },
        delete_database: {
          allowAccept: true,
          allowEdit: true,
          allowRespond: true,
        },
        // 自动批准安全操作
        search: false,
      },
    }),
  ],
  checkpointer: new MemorySaver(),
});

// Human in the Loop需要线程ID进行持久化
const config = { configurable: { thread_id: "some_id" } };

// 代理将在执行敏感工具前暂停并等待批准
let result = await agent.invoke(
  { messages: [{ role: "user", content: "给团队发一封电子邮件" }] },
  config,
);

result = await agent.invoke(
  new Command({ resume: { decisions: [{ type: "approve" }] } }),
  config, // 使用相同的线程ID恢复暂停的对话
);
```

<Tip>
  有关实施审批工作流的完整详情，请参阅[Human in the
  Loop文档](/oss/javascript/langchain/human-in-the-loop)。
</Tip>

## 自定义防护栏

对于更复杂的防护栏，您可以创建在代理执行前或后运行的自定义中间件。这让您可以完全控制验证逻辑、内容过滤和安全检查。

### 代理前防护栏

使用“代理前”钩子在每次调用开始时一次性验证请求。这对于会话级检查很有用，例如身份验证、速率限制或在任何处理开始前阻止不当请求。

```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { createMiddleware, AIMessage } from "langchain";

const contentFilterMiddleware = (bannedKeywords: string[]) => {
  const keywords = bannedKeywords.map((kw) => kw.toLowerCase());

  return createMiddleware({
    name: "ContentFilterMiddleware",
    beforeAgent: {
      hook: (state) => {
        // 获取第一条用户消息
        if (!state.messages || state.messages.length === 0) {
          return;
        }

        const firstMessage = state.messages[0];
        if (firstMessage._getType() !== "human") {
          return;
        }

        const content = firstMessage.content.toString().toLowerCase();

        // 检查禁止的关键词
        for (const keyword of keywords) {
          if (content.includes(keyword)) {
            // 在任何处理前阻止执行
            return {
              messages: [
                new AIMessage(
                  "我无法处理包含不当内容的请求。请重新表述您的请求。",
                ),
              ],
              jumpTo: "end",
            };
          }
        }

        return;
      },
      canJumpTo: ["end"],
    },
  });
};

// 使用自定义防护栏
import { createAgent } from "langchain";

const agent = createAgent({
  model: "gpt-5.4",
  tools: [searchTool, calculatorTool],
  middleware: [contentFilterMiddleware(["hack", "exploit", "malware"])],
});

// 此请求将在任何处理前被阻止
const result = await agent.invoke({
  messages: [{ role: "user", content: "我如何入侵数据库？" }],
});
```

### 代理后防护栏

使用“代理后”钩子在返回给用户前一次性验证最终输出。这对于基于模型的安全检查、质量验证或对完整代理响应的最终合规扫描很有用。

```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { createMiddleware, AIMessage, initChatModel } from "langchain";

const safetyGuardrailMiddleware = () => {
  const safetyModel = initChatModel("gpt-5.4-mini");

  return createMiddleware({
    name: "SafetyGuardrailMiddleware",
    afterAgent: {
      hook: async (state) => {
        // 获取最终的AI响应
        if (!state.messages || state.messages.length === 0) {
          return;
        }

        const lastMessage = state.messages[state.messages.length - 1];
        if (lastMessage._getType() !== "ai") {
          return;
        }

        // 使用模型评估安全性
        const safetyPrompt = `评估此响应是否安全且合适。
        仅回复 'SAFE' 或 'UNSAFE'。

        响应：${lastMessage.content.toString()}`;

        const result = await safetyModel.invoke([
          { role: "user", content: safetyPrompt },
        ]);

        if (result.content.toString().includes("UNSAFE")) {
          return {
            messages: [new AIMessage("我无法提供该响应。请重新表述您的请求。")],
            jumpTo: "end",
          };
        }

        return;
      },
      canJumpTo: ["end"],
    },
  });
};

// 使用安全防护栏
import { createAgent } from "langchain";

const agent = createAgent({
  model: "gpt-5.4",
  tools: [searchTool, calculatorTool],
  middleware: [safetyGuardrailMiddleware()],
});

const result = await agent.invoke({
  messages: [{ role: "user", content: "我如何制造爆炸物？" }],
});
```

### 组合多个防护栏

您可以通过将多个防护栏添加到中间件数组中来堆叠它们。它们按顺序执行，允许您构建分层保护：

```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import {
  createAgent,
  piiRedactionMiddleware,
  humanInTheLoopMiddleware,
} from "langchain";

const agent = createAgent({
  model: "gpt-5.4",
  tools: [searchTool, sendEmailTool],
  middleware: [
    // 第1层：确定性输入过滤器（代理前）
    contentFilterMiddleware(["hack", "exploit"]),

    // 第2层：PII保护（模型前后）
    piiRedactionMiddleware({
      piiType: "email",
      strategy: "redact",
      applyToInput: true,
    }),
    piiRedactionMiddleware({
      piiType: "email",
      strategy: "redact",
      applyToOutput: true,
    }),

    // 第3层：敏感工具的人工批准
    humanInTheLoopMiddleware({
      interruptOn: {
        send_email: { allowAccept: true, allowEdit: true, allowRespond: true },
      },
    }),

    // 第4层：基于模型的安全检查（代理后）
    safetyGuardrailMiddleware(),
  ],
});
```

## 附加资源

* [中间件文档](/oss/javascript/langchain/middleware) - 自定义中间件完整指南
* [中间件API参考](https://reference.langchain.com/python/langchain/middleware/) - 自定义中间件完整指南
* [Human in the Loop](/oss/javascript/langchain/human-in-the-loop) - 为敏感操作添加人工审查
* [测试代理](/oss/javascript/langchain/test/) - 测试安全机制的策略

***

<div className="source-links">
  <Callout icon="terminal-2">
    [将这些文档](/use-these-docs)通过MCP连接到Claude、VSCode等，以获取实时答案。
  </Callout>

  <Callout icon="edit">
    [在GitHub上编辑此页面](https://github.com/langchain-ai/docs/edit/main/src/oss/langchain/guardrails.mdx)或[提交问题](https://github.com/langchain-ai/docs/issues/new/choose)。
  </Callout>
</div>
