Nanbeige4.1-3B小模型安全实践：输入过滤、输出审核、敏感词拦截中间件集成

1. 引言：为什么小模型也需要安全防护？

你可能觉得，大模型才需要担心安全问题，小模型参数少，能出什么乱子？这个想法其实挺危险的。我见过不少开发者，把Nanbeige4.1-3B这样的小模型部署起来，直接开放给用户使用，结果没过多久就遇到了麻烦。

有人用模型生成不当内容，有人试图通过特殊提示词绕过限制，甚至还有人把模型当成了“免费助手”，让它帮忙写一些不该写的东西。这些情况一旦发生，轻则影响用户体验，重则可能引发法律风险。

Nanbeige4.1-3B虽然只有30亿参数，但它的推理能力和对话质量相当不错。正因为它“聪明”，我们才更需要为它加上安全护栏。今天我就来分享一套完整的安全实践方案，从输入到输出，全方位保护你的模型服务。

2. 理解Nanbeige4.1-3B的安全挑战

2.1 小模型的安全特性

Nanbeige4.1-3B作为一个小型开源模型，有它独特的安全特点：

• 推理能力强但边界模糊：模型在数学、逻辑推理上表现不错，但对安全边界的理解可能不如大模型那么清晰
• 响应直接：小模型往往更“听话”，用户问什么就答什么，缺少大模型那种“先思考再回答”的谨慎
• 微调影响大：由于参数少，任何微调都可能显著改变模型行为，包括安全行为

2.2 常见的安全风险场景

在实际使用中，我遇到过这些典型问题：

1. 直接请求不当内容：用户直接要求生成暴力、歧视性或违法信息
2. 间接诱导：通过复杂的提示词设计，试图让模型“无意中”说出不该说的话
3. 信息泄露：模型在回答中可能泄露训练数据中的敏感信息
4. 系统提示词绕过：用户通过特殊格式或重复请求，试图覆盖系统设定的安全指令

3. 三层安全防护架构设计

我设计的安全方案分为三个层次，就像给模型穿上了三层防护服：

用户输入 → 输入过滤层 → 模型推理 → 输出审核层 → 敏感词拦截 → 最终输出

每一层都有特定的职责，层层把关，确保安全。

3.1 第一层：输入过滤（守门员）

输入过滤是安全的第一道防线。它的任务是在用户的问题到达模型之前，就识别并拦截高风险请求。

核心思路：不是所有问题都值得让模型去思考。有些明显有问题的问题，直接拒绝就好。

下面是一个简单的输入过滤中间件实现：

class InputFilterMiddleware:
    def __init__(self):
        # 定义高风险关键词列表
        self.high_risk_keywords = [
            # 暴力相关
            "如何伤害", "制造武器", "攻击方法",
            # 违法内容
            "制作毒品", "非法获取", "黑客技术",
            # 歧视性内容
            "种族歧视", "性别歧视", "地域攻击",
            # 其他敏感内容
            "自杀方法", "自残指导"
        ]
        
        # 定义中度风险模式（正则表达式）
        self.medium_risk_patterns = [
            r"教我.*(骗|诈|偷)",  # 教我做坏事
            r"如何.*(报复|报复)",  # 报复相关
            r"最.*(毒|致命).*方法"  # 危险方法询问
        ]
        
    def check_input(self, user_input: str) -> dict:
        """
        检查用户输入，返回检查结果
        """
        result = {
            "safe": True,
            "risk_level": "low",
            "reason": "",
            "filtered_input": user_input
        }
        
        # 1. 检查高风险关键词
        for keyword in self.high_risk_keywords:
            if keyword in user_input:
                result["safe"] = False
                result["risk_level"] = "high"
                result["reason"] = f"检测到高风险关键词: {keyword}"
                return result
        
        # 2. 检查中度风险模式
        import re
        for pattern in self.medium_risk_patterns:
            if re.search(pattern, user_input, re.IGNORECASE):
                result["safe"] = False
                result["risk_level"] = "medium"
                result["reason"] = f"输入匹配风险模式: {pattern}"
                return result
        
        # 3. 检查输入长度（防止提示词注入攻击）
        if len(user_input) > 2000:
            # 过长的输入可能是试图覆盖系统提示词
            result["safe"] = False
            result["risk_level"] = "medium"
            result["reason"] = "输入过长，可能存在注入风险"
            return result
        
        # 4. 检查特殊字符比例（可能是编码或混淆的攻击）
        special_chars = sum(1 for c in user_input if not c.isalnum() and not c.isspace())
        if special_chars / len(user_input) > 0.3:  # 特殊字符超过30%
            result["safe"] = False
            result["risk_level"] = "medium"
            result["reason"] = "特殊字符比例过高"
            return result
        
        return result
    
    def filter_input(self, user_input: str) -> str:
        """
        对输入进行轻度过滤（替换敏感词）
        """
        filtered = user_input
        
        # 替换明显的脏话或攻击性词汇
        offensive_words = {
            "混蛋": "[已过滤]",
            "傻逼": "[已过滤]",
            "fuck": "[已过滤]",
            # 可以继续添加其他词汇
        }
        
        for word, replacement in offensive_words.items():
            filtered = filtered.replace(word, replacement)
        
        return filtered

这个过滤器的使用很简单：

# 在Chainlit应用中集成
filter = InputFilterMiddleware()

@cl.on_message
async def main(message: cl.Message):
    # 1. 检查输入安全性
    check_result = filter.check_input(message.content)
    
    if not check_result["safe"]:
        await cl.Message(
            content=f"抱歉，您的输入存在安全风险（{check_result['reason']}），请重新提问。"
        ).send()
        return
    
    # 2. 轻度过滤输入
    filtered_input = filter.filter_input(message.content)
    
    # 3. 将过滤后的输入发送给模型
    # ... 调用Nanbeige4.1-3B模型 ...

3.2 第二层：输出审核（质检员）

即使输入看起来安全，模型的输出也可能出问题。输出审核就是在模型生成回答后，对内容进行二次检查。

核心思路：模型可能“学坏”，或者被诱导生成不当内容。我们需要对它的输出进行把关。

class OutputValidator:
    def __init__(self):
        # 定义不允许出现的内容类型
        self.prohibited_content_types = {
            "violence": ["杀人", "伤害", "暴力", "攻击", "武器制作"],
            "illegal": ["毒品", "诈骗", "盗窃", "黑客", "违法"],
            "discrimination": ["种族", "性别", "地域", "歧视", "侮辱"],
            "sensitive": ["政府", "政治", "领导人", "敏感事件"]
        }
        
        # 定义内容质量检查规则
        self.quality_rules = {
            "min_length": 10,  # 最小长度
            "max_repetition": 3,  # 最大重复次数
            "coherence_threshold": 0.7  # 连贯性阈值
        }
    
    def validate_output(self, model_output: str) -> dict:
        """
        验证模型输出内容
        """
        result = {
            "valid": True,
            "issues": [],
            "suggested_action": "pass",  # pass, filter, regenerate
            "filtered_output": model_output
        }
        
        # 1. 检查禁止内容
        for content_type, keywords in self.prohibited_content_types.items():
            for keyword in keywords:
                if keyword in model_output:
                    result["valid"] = False
                    result["issues"].append(f"包含{content_type}相关内容: {keyword}")
                    result["suggested_action"] = "filter"
        
        # 2. 检查内容质量
        # 检查是否过于简短
        if len(model_output.strip()) < self.quality_rules["min_length"]:
            result["issues"].append("回答过于简短")
            result["suggested_action"] = "regenerate"
        
        # 检查重复内容
        words = model_output.split()
        if len(words) > 10:  # 只有长度足够时才检查重复
            word_counts = {}
            for word in words:
                word_counts[word] = word_counts.get(word, 0) + 1
            
            for word, count in word_counts.items():
                if count > self.quality_rules["max_repetition"] and len(word) > 1:
                    result["issues"].append(f"词语'{word}'重复{count}次")
                    if result["suggested_action"] == "pass":
                        result["suggested_action"] = "filter"
        
        # 3. 根据建议行动处理输出
        if result["suggested_action"] == "filter":
            # 过滤敏感内容
            result["filtered_output"] = self.filter_sensitive_content(model_output)
        elif result["suggested_action"] == "regenerate":
            # 标记需要重新生成
            result["filtered_output"] = "抱歉，我可能需要重新组织一下回答。"
        
        return result
    
    def filter_sensitive_content(self, text: str) -> str:
        """
        过滤输出中的敏感内容
        """
        filtered = text
        
        # 使用更温和的替换方式
        sensitive_patterns = {
            r"(毒品|吸毒|贩毒)": "[违禁品相关内容]",
            r"(杀人|伤害|暴力)": "[暴力相关内容]",
            r"(歧视|侮辱|攻击).*?(人|群体)": "[不尊重相关内容]"
        }
        
        import re
        for pattern, replacement in sensitive_patterns.items():
            filtered = re.sub(pattern, replacement, filtered, flags=re.IGNORECASE)
        
        return filtered

在Chainlit中集成输出审核：

validator = OutputValidator()

@cl.on_message
async def main(message: cl.Message):
    # ... 前面的输入过滤和模型调用 ...
    
    # 获取模型原始输出
    raw_output = await call_nanbeige_model(filtered_input)
    
    # 验证输出
    validation_result = validator.validate_output(raw_output)
    
    if not validation_result["valid"]:
        print(f"输出验证发现问题: {validation_result['issues']}")
    
    # 发送处理后的输出
    await cl.Message(content=validation_result["filtered_output"]).send()

3.3 第三层：敏感词实时拦截（最后防线）

这是最后一道防线，在内容返回给用户之前，进行最终的敏感词检查。即使前两层都通过了，这一层也能确保万无一失。

class SensitiveWordInterceptor:
    def __init__(self):
        # 加载敏感词库（可以从文件或数据库加载）
        self.sensitive_words = self.load_sensitive_words()
        
        # 配置拦截策略
        self.interception_strategy = {
            "strict_mode": False,  # 严格模式会拦截更多内容
            "replace_char": "*",   # 替换字符
            "min_word_length": 2   # 最小词长
        }
    
    def load_sensitive_words(self):
        """
        加载敏感词库
        实际项目中可以从文件或数据库加载
        """
        # 基础敏感词列表
        base_words = [
            # 违法内容相关
            "毒品", "枪支", "弹药", "爆炸物",
            # 暴力内容
            "杀人", "自杀", "暴力", "恐怖",
            # 政治敏感
            "国家机密", "军事秘密",
            # 其他
            "色情", "淫秽"
        ]
        
        # 可以添加词库文件加载逻辑
        # with open('sensitive_words.txt', 'r', encoding='utf-8') as f:
        #     words = [line.strip() for line in f if line.strip()]
        
        return set(base_words)
    
    def intercept(self, text: str) -> dict:
        """
        拦截敏感词
        """
        result = {
            "has_sensitive": False,
            "sensitive_words_found": [],
            "intercepted_text": text,
            "action_taken": "none"  # none, replaced, blocked
        }
        
        words_found = []
        
        # 检查每个敏感词
        for word in self.sensitive_words:
            if word in text:
                words_found.append(word)
        
        if words_found:
            result["has_sensitive"] = True
            result["sensitive_words_found"] = words_found
            
            if self.interception_strategy["strict_mode"]:
                # 严格模式：直接拦截整个回答
                result["intercepted_text"] = "抱歉，回答中包含敏感内容，已拦截。"
                result["action_taken"] = "blocked"
            else:
                # 普通模式：替换敏感词
                intercepted_text = text
                for word in words_found:
                    if len(word) >= self.interception_strategy["min_word_length"]:
                        replacement = self.interception_strategy["replace_char"] * len(word)
                        intercepted_text = intercepted_text.replace(word, replacement)
                
                result["intercepted_text"] = intercepted_text
                result["action_taken"] = "replaced"
        
        return result
    
    def add_custom_words(self, words: list):
        """
        添加自定义敏感词
        """
        self.sensitive_words.update(words)
    
    def remove_words(self, words: list):
        """
        移除敏感词（谨慎使用）
        """
        for word in words:
            if word in self.sensitive_words:
                self.sensitive_words.remove(word)

在完整流程中集成三层防护：

class SecureAIChat:
    def __init__(self):
        self.input_filter = InputFilterMiddleware()
        self.output_validator = OutputValidator()
        self.word_interceptor = SensitiveWordInterceptor()
        
    async def process_message(self, user_input: str) -> str:
        """
        完整的安全处理流程
        """
        # 1. 输入过滤
        input_check = self.input_filter.check_input(user_input)
        if not input_check["safe"]:
            return f"输入安全检查未通过: {input_check['reason']}"
        
        filtered_input = self.input_filter.filter_input(user_input)
        
        # 2. 调用模型（这里简化了模型调用）
        # 实际项目中这里会调用Nanbeige4.1-3B模型
        model_output = await self.call_model(filtered_input)
        
        # 3. 输出审核
        validation_result = self.output_validator.validate_output(model_output)
        
        if validation_result["suggested_action"] == "regenerate":
            # 如果需要重新生成，可以尝试一次
            model_output = await self.call_model(filtered_input + " [请提供更详细的回答]")
            validation_result = self.output_validator.validate_output(model_output)
        
        intermediate_output = validation_result["filtered_output"]
        
        # 4. 敏感词拦截
        interception_result = self.word_interceptor.intercept(intermediate_output)
        
        final_output = interception_result["intercepted_text"]
        
        # 记录安全事件（实际项目中应该记录到日志）
        if (not input_check["safe"] or 
            not validation_result["valid"] or 
            interception_result["has_sensitive"]):
            self.log_security_event({
                "input": user_input,
                "input_check": input_check,
                "validation": validation_result,
                "interception": interception_result
            })
        
        return final_output
    
    async def call_model(self, prompt: str) -> str:
        """
        调用Nanbeige4.1-3B模型
        这里是一个简化示例，实际需要根据你的部署方式调整
        """
        # 实际调用代码取决于你的部署方式
        # 例如使用vLLM的调用方式：
        # from vllm import LLM, SamplingParams
        # llm = LLM(model="/path/to/nanbeige")
        # outputs = llm.generate([prompt])
        # return outputs[0].outputs[0].text
        
        # 这里返回模拟响应
        return f"这是模型对'{prompt}'的模拟响应。"
    
    def log_security_event(self, event_data: dict):
        """
        记录安全事件
        """
        # 实际项目中应该记录到文件或日志系统
        print(f"[安全事件] {event_data}")

4. 在Chainlit中完整集成安全中间件

现在，让我们把所有这些安全组件集成到你的Chainlit应用中。假设你已经用vLLM部署了Nanbeige4.1-3B，下面是如何安全地调用它：

import chainlit as cl
from typing import Optional
import asyncio

# 导入我们之前定义的安全组件
from secure_middleware import SecureAIChat

class NanbeigeChatApp:
    def __init__(self):
        # 初始化安全处理器
        self.secure_chat = SecureAIChat()
        
        # 初始化模型（这里需要根据你的实际部署调整）
        self.initialize_model()
        
        # 对话历史
        self.conversation_history = []
        
    def initialize_model(self):
        """
        初始化Nanbeige4.1-3B模型
        根据你的vLLM部署方式调整
        """
        # 示例：使用vLLM
        # from vllm import LLM, SamplingParams
        # self.llm = LLM(
        #     model="/root/workspace/nanbeige-4.1-3b",
        #     tensor_parallel_size=1,
        #     gpu_memory_utilization=0.9
        # )
        # self.sampling_params = SamplingParams(
        #     temperature=0.7,
        #     top_p=0.9,
        #     max_tokens=512
        # )
        
        print("模型初始化完成（示例中为模拟）")
    
    async def generate_response(self, prompt: str) -> str:
        """
        生成模型响应（带安全防护）
        """
        # 使用安全处理器处理
        response = await self.secure_chat.process_message(prompt)
        
        # 记录对话历史（可选，注意隐私）
        self.conversation_history.append({
            "user": prompt,
            "assistant": response,
            "timestamp": asyncio.get_event_loop().time()
        })
        
        # 保持历史记录长度
        if len(self.conversation_history) > 10:
            self.conversation_history = self.conversation_history[-10:]
        
        return response

# 创建应用实例
app = NanbeigeChatApp()

@cl.on_chat_start
async def start_chat():
    """
    聊天开始时的初始化
    """
    # 发送欢迎消息
    welcome_msg = """欢迎使用安全增强版的Nanbeige4.1-3B聊天助手！

我已经集成了多层安全防护：
1. 输入过滤 - 检查您的问题是否安全
2. 输出审核 - 确保我的回答符合规范
3. 敏感词拦截 - 最后一道安全防线

请放心提问，我会在安全的前提下为您提供帮助！"""
    
    await cl.Message(content=welcome_msg).send()

@cl.on_message
async def handle_message(message: cl.Message):
    """
    处理用户消息
    """
    # 显示思考状态
    thinking_msg = cl.Message(content="正在思考中...")
    await thinking_msg.send()
    
    try:
        # 生成响应
        response = await app.generate_response(message.content)
        
        # 更新消息内容
        thinking_msg.content = response
        await thinking_msg.update()
        
    except Exception as e:
        # 错误处理
        error_msg = f"抱歉，处理您的请求时出现了错误: {str(e)}"
        thinking_msg.content = error_msg
        await thinking_msg.update()

@cl.on_chat_end
async def end_chat():
    """
    聊天结束时的清理工作
    """
    # 可以在这里保存对话记录或进行其他清理
    print(f"对话结束，共进行了{len(app.conversation_history)}轮对话")

5. 高级安全特性与最佳实践

5.1 动态敏感词库更新

静态的敏感词库容易过时，我们可以实现动态更新机制：

class DynamicSensitiveWordManager:
    def __init__(self):
        self.local_word_set = set()  # 本地词库
        self.remote_word_url = None  # 远程词库URL
        self.update_interval = 3600  # 更新间隔（秒）
        self.last_update = 0
        
    async def update_word_set(self):
        """
        更新敏感词库
        """
        current_time = asyncio.get_event_loop().time()
        
        # 检查是否需要更新
        if current_time - self.last_update < self.update_interval:
            return
        
        try:
            # 从远程获取最新词库
            if self.remote_word_url:
                async with aiohttp.ClientSession() as session:
                    async with session.get(self.remote_word_url) as response:
                        if response.status == 200:
                            new_words = await response.text()
                            words_list = new_words.split('\n')
                            self.local_word_set.update([w.strip() for w in words_list if w.strip()])
            
            # 从本地文件加载（备用）
            local_file = "sensitive_words_local.txt"
            if os.path.exists(local_file):
                with open(local_file, 'r', encoding='utf-8') as f:
                    local_words = [line.strip() for line in f if line.strip()]
                    self.local_word_set.update(local_words)
            
            self.last_update = current_time
            print(f"敏感词库已更新，当前词数: {len(self.local_word_set)}")
            
        except Exception as e:
            print(f"更新敏感词库失败: {e}")
    
    def add_user_reported_word(self, word: str, context: str):
        """
        添加用户举报的敏感词
        """
        # 可以添加验证逻辑，比如需要多个用户举报才加入
        self.local_word_set.add(word)
        
        # 记录举报上下文
        report_log = {
            "word": word,
            "context": context,
            "timestamp": time.time(),
            "reporter": "user"  # 实际项目中可以记录用户ID
        }
        
        # 保存到文件或数据库
        self.save_report_log(report_log)

5.2 用户行为分析与异常检测

除了内容安全，我们还需要关注用户行为：

class UserBehaviorAnalyzer:
    def __init__(self):
        self.user_sessions = {}  # 用户会话记录
        self.suspicious_patterns = [
            "high_frequency",  # 高频请求
            "repeated_reject",  # 重复被拒绝
            "rapid_topic_change",  # 快速切换话题
            "probing_questions"  # 探测性问题
        ]
    
    def track_user_behavior(self, user_id: str, action: str, details: dict):
        """
        跟踪用户行为
        """
        if user_id not in self.user_sessions:
            self.user_sessions[user_id] = {
                "start_time": time.time(),
                "actions": [],
                "reject_count": 0,
                "last_actions": []
            }
        
        session = self.user_sessions[user_id]
        session["actions"].append({
            "action": action,
            "details": details,
            "timestamp": time.time()
        })
        
        # 保持最近10个动作
        session["last_actions"] = session["actions"][-10:]
        
        # 检查可疑行为
        risk_score = self.assess_risk(user_id)
        
        if risk_score > 0.7:  # 高风险阈值
            print(f"警告：用户 {user_id} 行为可疑，风险分数: {risk_score}")
            # 可以触发额外验证或限制访问
    
    def assess_risk(self, user_id: str) -> float:
        """
        评估用户风险分数
        """
        if user_id not in self.user_sessions:
            return 0.0
        
        session = self.user_sessions[user_id]
        risk_score = 0.0
        
        # 1. 检查请求频率
        if len(session["actions"]) > 50:  # 短时间内大量请求
            risk_score += 0.3
        
        # 2. 检查被拒绝的比例
        reject_actions = [a for a in session["actions"] if a.get("details", {}).get("rejected")]
        if len(session["actions"]) > 0:
            reject_ratio = len(reject_actions) / len(session["actions"])
            if reject_ratio > 0.5:  # 超过50%被拒绝
                risk_score += 0.4
        
        # 3. 检查话题切换频率
        # 这里可以添加更复杂的逻辑
        
        return min(risk_score, 1.0)  # 确保不超过1.0

5.3 安全日志与审计

完整的安全系统需要有完善的日志记录：

import json
import time
from datetime import datetime

class SecurityLogger:
    def __init__(self, log_file: str = "security.log"):
        self.log_file = log_file
        
    def log_event(self, event_type: str, data: dict):
        """
        记录安全事件
        """
        log_entry = {
            "timestamp": datetime.now().isoformat(),
            "event_type": event_type,
            "data": data,
            "severity": self._determine_severity(event_type, data)
        }
        
        # 写入日志文件
        with open(self.log_file, 'a', encoding='utf-8') as f:
            f.write(json.dumps(log_entry, ensure_ascii=False) + '\n')
        
        # 同时打印到控制台（实际项目中可能不需要）
        print(f"[安全日志] {event_type}: {data}")
    
    def _determine_severity(self, event_type: str, data: dict) -> str:
        """
        确定事件严重程度
        """
        if event_type in ["high_risk_input", "sensitive_content_output"]:
            return "HIGH"
        elif event_type in ["medium_risk_input", "content_validation_failed"]:
            return "MEDIUM"
        else:
            return "LOW"
    
    def get_recent_events(self, hours: int = 24) -> list:
        """
        获取最近的安全事件
        """
        recent_events = []
        cutoff_time = time.time() - hours * 3600
        
        try:
            with open(self.log_file, 'r', encoding='utf-8') as f:
                for line in f:
                    try:
                        event = json.loads(line.strip())
                        event_time = datetime.fromisoformat(event["timestamp"]).timestamp()
                        
                        if event_time >= cutoff_time:
                            recent_events.append(event)
                    except:
                        continue
        except FileNotFoundError:
            pass
        
        return recent_events

6. 部署与监控建议

6.1 部署配置

在实际部署时，建议这样配置你的安全中间件：

# security_config.yaml
security:
  input_filter:
    enabled: true
    strict_mode: false
    max_input_length: 2000
    check_special_chars: true
    
  output_validator:
    enabled: true
    min_response_length: 10
    check_repetition: true
    max_repetition_count: 3
    
  word_interceptor:
    enabled: true
    strict_mode: false
    word_source: 
      - "local:./config/sensitive_words.txt"
      - "remote:https://example.com/sensitive_words.txt"
    update_interval: 3600
    
  logging:
    enabled: true
    log_file: "./logs/security.log"
    retention_days: 30
    alert_threshold: 10  # 每小时超过10个安全事件触发告警
    
  rate_limiting:
    enabled: true
    requests_per_minute: 60
    requests_per_hour: 1000

6.2 监控指标

建立关键监控指标，确保安全系统正常运行：

1. 输入过滤统计：

   • 每日拦截的高风险请求数
   • 最常见的风险类型
   • 误报率（如果可能跟踪）

2. 输出审核统计：

   • 每日过滤/重生成的回答数
   • 内容质量问题分布
   • 审核耗时统计

3. 敏感词拦截统计：

   • 每日拦截的敏感词次数
   • 高频敏感词TOP 10
   • 拦截模式分布（替换 vs 拦截）

4. 系统性能指标：

   • 安全处理平均延迟
   • 内存使用情况
   • CPU使用率

6.3 定期维护任务

1. 每周：

   • 审查安全日志，分析新出现的风险模式
   • 更新敏感词库
   • 检查系统性能指标

2. 每月：

   • 评估误报率，调整过滤规则
   • 分析用户反馈，优化安全策略
   • 备份安全配置和日志

3. 每季度：

   • 进行安全审计
   • 更新安全策略文档
   • 培训团队成员

7. 总结

为Nanbeige4.1-3B这样的小模型添加安全防护，不是可选项，而是必选项。通过今天分享的三层防护架构——输入过滤、输出审核、敏感词拦截，你可以构建一个既安全又实用的AI对话系统。

关键要点回顾：

1. 输入过滤是守门员：在问题到达模型前就拦截高风险请求，节省计算资源，保护模型安全。

2. 输出审核是质检员：检查模型的回答是否合适，过滤不当内容，确保输出质量。

3. 敏感词拦截是最后防线：即使前两层都通过，这一层也能确保万无一失。

4. 安全需要持续维护：定期更新词库、分析日志、优化规则，安全是一个持续的过程。

5. 平衡安全与体验：过于严格的安全策略会影响用户体验，需要在安全和可用性之间找到平衡。

这套方案我已经在实际项目中验证过，能够有效防止大多数常见的安全问题。当然，没有绝对的安全系统，重要的是建立持续改进的机制。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。