AI Agent在智能风控中的多智能体协同：从规则到AI的演进维护

关键词：AI Agent、多智能体协同、智能风控、规则引擎、机器学习、金融科技、风险管理

摘要：本文将深入浅出地介绍AI Agent在智能风控领域的应用，以及多智能体协同如何革新传统风控体系。我们将像讲故事一样，从简单的规则引擎开始，一步步探索到复杂的AI Agent协同系统，用生动的比喻和清晰的逻辑，让每个读者都能理解这一前沿技术的魅力。

---

背景介绍

目的和范围

在当今这个数字化时代，金融服务就像空气一样无处不在——从网上购物付款，到申请贷款买房，再到投资理财，我们的生活越来越离不开金融科技。但是，在享受便利的同时，风险也像一只看不见的手，随时可能给我们带来麻烦。这就是为什么"风控"（风险控制）变得如此重要。

本文的目的，就是要带大家探索风控的演变历程，特别是AI Agent（人工智能智能体）和多智能体协同技术是如何让风控变得更聪明、更强大的。我们会从最简单的"规则"讲起，一直到最前沿的"AI协同"，让每个读者都能明白这其中的奥妙。

预期读者

这篇文章适合所有对金融科技、人工智能感兴趣的朋友，无论你是程序员、产品经理、金融从业者，还是只是一个对新技术好奇的普通人。我们会用最通俗易懂的语言，像给小学生讲故事一样，把复杂的技术讲清楚。

文档结构概述

我们的探索之旅将按照以下路线展开：

1. 首先，我们会了解一些核心概念，就像认识新朋友一样
2. 然后，我们会回顾风控的演变历史，看看它是如何从简单规则一步步发展到AI Agent的
3. 接着，我们会深入探讨多智能体协同的原理和架构
4. 之后，我们会看一些实际的应用案例
5. 最后，我们会展望未来，讨论这一技术的发展趋势和挑战

术语表

在我们开始之前，先认识几个重要的"小伙伴"，它们会在我们的故事中频繁出现。

核心术语定义

• 风控：就像给金融安全加一把锁，识别和阻止不好的事情发生
• AI Agent：一个有自己"想法"和"行动能力"的AI小程序，就像一个小助手
• 多智能体协同：多个AI小助手一起合作，就像足球队员互相配合赢比赛
• 规则引擎：一套"如果…就…"的规则，就像学校里的校规校纪

相关概念解释

• 机器学习：让电脑自己从数据中"学习"规律，就像我们从经验中学习一样
• 深度学习：机器学习的一种更高级形式，模拟人脑的神经网络工作
• 欺诈检测：识别骗子的行为，就像警察抓小偷
• 信用评估：判断一个人是否靠谱，就像了解一个新朋友值不值得信任

缩略词列表

• AI：人工智能（Artificial Intelligence）
• ML：机器学习（Machine Learning）
• DL：深度学习（Deep Learning）
• KPI：关键绩效指标（Key Performance Indicator）
• API：应用程序编程接口（Application Programming Interface）

---

核心概念与联系

故事引入

让我先给大家讲一个小故事。

假设你是一家小超市的老板，你有一个问题：有些顾客来买东西，总是赊账不还。一开始，你凭感觉判断谁靠谱谁不靠谱——你觉得看起来老实的人就可以赊账，看起来鬼鬼祟祟的就不行。但这经常出错，有些看起来老实的人也会跑路，让你损失不少钱。

后来，你想出了一个办法：制定一些规则。比如，“如果是住在附近的老顾客，就可以赊账”，“如果买的东西超过1000块，就不能赊账”，“如果之前有过不还钱的记录，坚决不赊账”。这些规则让你的损失减少了一些，但还是不够灵活——有一个新搬来的顾客，虽然是第一次来，但一看就是个有钱人，你却因为"新顾客不能赊账"的规则错过了生意。

再后来，你变得更聪明了。你开始记录每个顾客的各种信息：住在哪个小区、做什么工作、每个月来买几次东西、每次买什么、之前赊账有没有按时还等等。你把这些信息告诉你的一个聪明朋友，让他帮你分析。这个朋友通过分析大量的数据，找出了一些规律：比如，“住在花园小区的老师，95%都会按时还钱”，“每次买烟买酒的人，有30%可能不还钱”。这些规律比你之前的简单规则好用多了。

现在，你不仅仅满足于此。你雇了好几个聪明的助手，每个助手负责不同的事情：一个负责观察顾客的行为，一个负责调查顾客的背景，一个负责计算风险大小，还有一个负责做最终决定。这些助手之间会互相交流信息，一起合作，就像一个小团队。这样一来，你的判断就更准确了，既不会让骗子得逞，也不会错过好顾客。

这个小故事，其实就是风控从简单到复杂的演变过程。而我们今天要讲的，就是最后那个阶段——多个聪明的AI助手（AI Agent）一起合作（多智能体协同）来做风控的故事。

核心概念解释（像给小学生讲故事一样）

让我们来认识一下今天故事里的几个主角。

核心概念一：什么是风控？

风控，就是"风险控制"的简称。就像我们过马路要左右看、下雨要打伞一样，风控就是提前发现可能的危险，想办法避免或者减少损失。

在金融世界里，风控就是银行、支付公司这些金融机构的"安全卫士"。它们的工作包括：

• 识别骗子（欺诈检测）
• 判断一个人借钱后会不会还（信用评估）
• 防止洗黑钱（反洗钱）
• 确保金融系统稳定运行（市场风险控制）

就像我们故事里的超市老板，金融机构也不想把钱给不靠谱的人，也不想被骗子骗钱。

核心概念二：什么是AI Agent？

AI Agent，我们可以叫它"人工智能智能体"，但这个名字太拗口了，我们就叫它"AI小助手"吧。

想象一下，你有一个特别聪明的机器人助手，它不仅能听懂你的话，还能自己观察周围的情况，自己做决定，自己采取行动。比如，你告诉它"帮我照顾好家里"，它会自己观察天气，如果下雨了就关窗户，如果发现陌生人靠近就报警，如果家里太脏就扫地。这就是一个AI Agent。

在技术上，AI Agent是一个能够感知环境、做出决策、执行动作的计算机程序。它有几个特点：

1. 自主性：它可以自己做决定，不需要事事都问你
2. 反应性：它能感知周围的变化，并及时做出反应
3. 主动性：它不仅会被动反应，还会主动设定目标并努力实现
4. 社交能力：它能和其他AI Agent或者人类交流合作

在我们的风控故事里，每个AI小助手可能负责不同的工作，有的负责分析用户的行为数据，有的负责查背景信息，有的负责计算风险。

核心概念三：什么是多智能体协同？

“多智能体协同”，就是多个AI小助手一起合作完成任务。就像踢足球一样，每个球员有不同的位置（前锋、中场、后卫、守门员），大家互相配合，才能赢得比赛。

为什么需要多个AI小助手一起合作呢？因为：

1. 任务太复杂：一个AI小助手可能搞不定所有事情，需要分工合作
2. 专业的人做专业的事：每个AI小助手可以专门擅长某一方面，然后互相补充
3. 容错性更好：即使一个AI小助手出错了，其他的可以帮忙纠正
4. 效率更高：多个AI小助手可以同时做不同的事情，就像流水线一样

在风控场景中，可能有一个AI小助手专门分析用户的交易行为，另一个专门分析用户的社交媒体数据，还有一个专门和历史上的欺诈案例做对比，最后大家一起商量，判断这个交易是不是有问题。

核心概念四：从规则到AI的演进

就像我们开头的小故事一样，风控的发展也经历了几个阶段：

第一阶段：人工经验阶段
就像超市老板一开始凭感觉判断谁靠谱谁不靠谱。这个阶段全靠人的经验，容易出错，而且效率很低。

第二阶段：规则引擎阶段
超市老板制定了一些"如果…就…“的规则。比如"如果是老顾客，就可以赊账”。这个阶段比人工经验靠谱一些，但不够灵活，也没法处理复杂的情况。

第三阶段：机器学习阶段
超市老板让聪明的朋友从大量数据中找出规律。这个阶段系统可以自己"学习"，比死板的规则更灵活，但通常只能做单一的判断，缺少协作。

第四阶段：AI Agent与多智能体协同阶段
超市老板雇了好几个聪明的助手，大家分工合作。这就是我们现在正在进入的阶段，也是最强大、最智能的阶段。

核心概念之间的关系（用小学生能理解的比喻）

现在，让我们看看这些概念之间是怎么"合作"的，就像看一个团队怎么一起完成任务。

风控和AI Agent的关系

风控就像"任务"，AI Agent就像"执行任务的人"。我们需要AI Agent来帮助我们完成风控这个任务。如果说风控是"打扫卫生"，那么AI Agent就是"扫地机器人"、“擦窗户机器人”、“整理房间机器人”。

AI Agent和多智能体协同的关系

一个AI Agent可能很能干，但就像一个人再能干，也没法同时做好所有事情。多智能体协同就是让多个AI Agent一起合作，就像一个施工队，有人搬砖，有人和水泥，有人砌墙，大家一起才能把房子盖好。

从规则到AI的演进和它们的关系

这就像交通工具的演变：

• 人工经验阶段：走路
• 规则引擎阶段：骑自行车
• 机器学习阶段：开汽车
• AI Agent与多智能体协同阶段：开飞机，而且是编队飞行的飞机群

每一个新阶段都比前一个更快、更强、更灵活，但它们也不是完全替代的关系——有时候我们还是需要走路（人工审核），有时候骑自行车（规则）也很方便。

核心概念原理和架构的文本示意图

让我们用文字来画一张图，看看多智能体协同风控系统是怎么工作的：

想象一个工厂的流水线，不过这个工厂不是生产产品，而是"生产"安全的金融交易。

1. 入口处：一笔交易进来了，就像一个包裹进入了工厂
2. 第一道工序："行为分析小助手"检查这个交易的行为模式——是不是在奇怪的时间交易？是不是交易金额突然变大？是不是和平时的交易习惯不一样？
3. 第二道工序："背景调查小助手"去查用户的背景——这个人信用怎么样？有没有犯罪记录？收入稳定吗？
4. 第三道工序："欺诈对比小助手"把这个交易和历史上的欺诈案例做对比——有没有类似的骗局发生过？
5. 第四道工序："风险计算小助手"根据前面几个小助手的发现，计算出这笔交易的风险分数
6. 第五道工序："决策小助手"根据风险分数做决定——是直接通过？还是需要进一步检查？还是直接拒绝？
7. 出口处：交易带着决定离开工厂

在这个过程中，这些小助手之间不是独立工作的，它们会互相交流信息。比如，“行为分析小助手"发现交易时间很奇怪，会告诉"风险计算小助手”，让它把这一点考虑进去。

Mermaid 流程图

让我们用更专业的流程图来展示这个过程：

这个流程图展示了一个完整的多智能体协同风控系统的工作流程。我们可以看到，交易进来后，会有多个Agent同时分析，然后它们共享信息，一起计算风险，做出决策。而且，系统还会从人工审核的结果中学习，不断优化自己。

---

核心算法原理 & 具体操作步骤

现在，让我们深入一点，看看这些AI小助手到底是怎么工作的。我们会用一些简单的代码示例，让大家更直观地理解。

规则引擎：风控的基础

在开始讲AI之前，我们先看看规则引擎是怎么工作的，因为这是风控的基础，也是很多AI系统的补充。

规则引擎其实就是一系列的"如果…就…"规则。比如：

• 如果用户是第一次交易，而且金额超过10000元，就标记为可疑
• 如果用户在24小时内交易超过5次，就标记为可疑
• 如果用户的交易地点和平时不一样，就标记为可疑

让我们用Python写一个简单的规则引擎：

class RuleEngine:
    def __init__(self):
        self.rules = []
    
    def add_rule(self, rule):
        """添加一条规则"""
        self.rules.append(rule)
    
    def evaluate(self, transaction):
        """评估一笔交易，返回风险分数"""
        risk_score = 0
        triggered_rules = []
        
        for rule in self.rules:
            if rule.check(transaction):
                risk_score += rule.weight
                triggered_rules.append(rule.name)
        
        return risk_score, triggered_rules


class Rule:
    def __init__(self, name, check_func, weight):
        self.name = name
        self.check = check_func  # 检查规则是否触发的函数
        self.weight = weight     # 规则的权重，即触发后增加多少风险分


# 创建一个规则引擎
engine = RuleEngine()

# 添加一些规则
engine.add_rule(Rule(
    "大额首次交易",
    lambda t: t['is_first'] and t['amount'] > 10000,
    50
))

engine.add_rule(Rule(
    "频繁交易",
    lambda t: t['transaction_count_24h'] > 5,
    30
))

engine.add_rule(Rule(
    "异常地点",
    lambda t: t['location'] != t['usual_location'],
    20
))

# 测试一笔交易
transaction1 = {
    'is_first': True,
    'amount': 15000,
    'transaction_count_24h': 3,
    'location': '北京',
    'usual_location': '北京'
}

risk_score1, triggered_rules1 = engine.evaluate(transaction1)
print(f"交易1风险分数: {risk_score1}")
print(f"触发的规则: {triggered_rules1}")

# 测试另一笔交易
transaction2 = {
    'is_first': False,
    'amount': 500,
    'transaction_count_24h': 10,
    'location': '上海',
    'usual_location': '北京'
}

risk_score2, triggered_rules2 = engine.evaluate(transaction2)
print(f"\n交易2风险分数: {risk_score2}")
print(f"触发的规则: {triggered_rules2}")

这个简单的规则引擎展示了风控的基本思路：设定一些规则，检查交易是否触发这些规则，然后根据触发的规则计算风险分数。

但是，规则引擎有一个明显的问题：它太死板了。骗子只要稍微改变一下行为，规则就可能失效。而且，我们不可能预见到所有可能的欺诈方式。这就是为什么我们需要更智能的方法——机器学习。

机器学习：让系统自己学习

机器学习的核心思想是：让系统从大量的数据中自己找出规律，而不是我们手动编写规则。

想象一下，你有一本相册，里面有很多猫和狗的照片。如果你想让一个小孩学会区分猫和狗，你不会给他写一堆规则（比如"猫的耳朵是尖的，狗的耳朵是圆的"），你会直接给他看很多照片，告诉他"这是猫，这是狗"，让他自己总结规律。机器学习就是这样工作的。

在风控场景中，我们会给系统看很多历史交易数据，告诉它哪些是正常交易，哪些是欺诈交易，让它自己找出欺诈交易的特征。

让我们用Python写一个简单的机器学习风控模型：

import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

# 生成一些模拟数据
# 特征包括：交易金额、是否首次交易、24小时交易次数、位置是否异常、历史信用分数
np.random.seed(42)
n_samples = 1000

# 正常交易
normal_transactions = np.random.normal(loc=[500, 0, 2, 0, 700], scale=[200, 0.1, 1, 0.1, 100], size=(n_samples//2, 5))
normal_labels = np.zeros(n_samples//2)

# 欺诈交易
fraud_transactions = np.random.normal(loc=[5000, 0.8, 8, 0.7, 400], scale=[3000, 0.2, 3, 0.2, 150], size=(n_samples//2, 5))
fraud_labels = np.ones(n_samples//2)

# 合并数据
X = np.vstack([normal_transactions, fraud_transactions])
y = np.hstack([normal_labels, fraud_labels])

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 训练一个随机森林分类器
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 预测测试集
y_pred = model.predict(X_test)

# 评估模型
print(f"准确率: {accuracy_score(y_test, y_pred):.4f}")
print(f"精确率: {precision_score(y_test, y_pred):.4f}")
print(f"召回率: {recall_score(y_test, y_pred):.4f}")
print(f"F1分数: {f1_score(y_test, y_pred):.4f}")

# 看看特征重要性
feature_names = ['交易金额', '是否首次交易', '24小时交易次数', '位置是否异常', '历史信用分数']
importances = model.feature_importances_
print("\n特征重要性:")
for name, importance in zip(feature_names, importances):
    print(f"{name}: {importance:.4f}")

# 用模型预测一笔新交易
def predict_transaction(model, transaction):
    # 预测欺诈概率
    fraud_probability = model.predict_proba([transaction])[0][1]
    return fraud_probability

# 测试一笔看起来正常的交易
normal_transaction = [300, 0, 1, 0, 750]
fraud_prob1 = predict_transaction(model, normal_transaction)
print(f"\n正常交易的欺诈概率: {fraud_prob1:.4f}")

# 测试一笔看起来可疑的交易
suspicious_transaction = [8000, 1, 10, 1, 350]
fraud_prob2 = predict_transaction(model, suspicious_transaction)
print(f"可疑交易的欺诈概率: {fraud_prob2:.4f}")

这个例子展示了机器学习在风控中的应用。我们用随机森林算法训练了一个模型，它可以根据交易的几个特征，预测这笔交易是欺诈的概率。

机器学习比规则引擎灵活多了，它可以发现我们人类可能想不到的规律。但是，它也有局限性：

1. 它是一个"黑盒子"——我们不知道它为什么做出某个判断
2. 它通常只能处理结构化的数据，对于文本、图像等非结构化数据处理起来比较困难
3. 它缺少协作能力——每个模型都是独立工作的

这就是为什么我们需要更高级的技术——AI Agent和多智能体协同。

AI Agent：有"思考"能力的智能体

AI Agent比简单的机器学习模型更进了一步——它不仅能从数据中学习，还能感知环境、做出决策、执行行动，并且能和其他Agent交流合作。

一个AI Agent通常由以下几个部分组成：

1. 感知模块：负责收集环境信息
2. 推理/决策模块：根据感知到的信息和已有的知识，做出决策
3. 行动模块：执行决策
4. 记忆/知识模块：存储经验和知识
5. 通信模块：和其他Agent或人类交流

让我们用Python实现一个简单的AI Agent：

import time
import random

class AIAgent:
    def __init__(self, name, role):
        self.name = name
        self.role = role
        self.knowledge = {}  # 知识库
        self.memory = []     # 记忆
        self.message_queue = []  # 消息队列
    
    def perceive(self, environment):
        """感知环境"""
        # 在实际应用中，这里会收集各种环境信息
        print(f"{self.name} 正在感知环境...")
        return environment.get_info()
    
    def reason(self, information):
        """推理和决策"""
        # 在实际应用中，这里会有复杂的推理逻辑
        print(f"{self.name} 正在分析信息...")
        decision = self._make_decision(information)
        return decision
    
    def act(self, decision):
        """执行行动"""
        print(f"{self.name} 正在执行行动: {decision}")
        # 在实际应用中，这里会执行具体的行动
        return f"行动 '{decision}' 已完成"
    
    def communicate(self, other_agent, message):
        """和其他Agent交流"""
        print(f"{self.name} 向 {other_agent.name} 发送消息: {message}")
        other_agent.receive_message(self, message)
    
    def receive_message(self, sender, message):
        """接收消息"""
        print(f"{self.name} 收到来自 {sender.name} 的消息: {message}")
        self.message_queue.append((sender, message))
    
    def learn(self, experience):
        """从经验中学习"""
        print(f"{self.name} 正在从经验中学习...")
        # 在实际应用中，这里会更新模型或知识库
        self.memory.append(experience)
        self.knowledge.update(experience.get('knowledge', {}))
    
    def _make_decision(self, information):
        """内部决策逻辑（简单示例）"""
        # 在实际应用中，这里可能会使用机器学习模型、规则引擎等
        risk_score = information.get('risk_score', 0)
        if risk_score > 70:
            return "拒绝交易"
        elif risk_score > 30:
            return "人工审核"
        else:
            return "通过交易"
    
    def run(self, environment):
        """运行Agent的主循环"""
        print(f"\n{'='*50}")
        print(f"{self.name} 开始工作")
        print(f"{'='*50}")
        
        # 感知环境
        info = self.perceive(environment)
        
        # 处理消息队列
        while self.message_queue:
            sender, message = self.message_queue.pop(0)
            print(f"{self.name} 处理来自 {sender.name} 的消息: {message}")
            # 在实际应用中，这里会根据消息做出反应
        
        # 推理和决策
        decision = self.reason(info)
        
        # 执行行动
        result = self.act(decision)
        
        # 学习
        experience = {
            'information': info,
            'decision': decision,
            'result': result,
            'knowledge': {'last_risk_score': info.get('risk_score', 0)}
        }
        self.learn(experience)
        
        return decision, result


class Environment:
    """模拟环境"""
    def __init__(self):
        self.transaction = None
    
    def set_transaction(self, transaction):
        """设置当前交易"""
        self.transaction = transaction
    
    def get_info(self):
        """获取环境信息"""
        # 在实际应用中，这里会返回各种环境信息
        if self.transaction:
            return {
                'transaction_id': self.transaction.get('id'),
                'risk_score': self.transaction.get('risk_score', 0),
                'amount': self.transaction.get('amount', 0),
                'user_id': self.transaction.get('user_id')
            }
        return {}


# 创建环境
env = Environment()

# 创建几个Agent
behavior_agent = AIAgent("行为分析Agent", "分析用户交易行为")
background_agent = AIAgent("背景调查Agent", "调查用户背景信息")
decision_agent = AIAgent("决策Agent", "做出最终决策")

# 设置一笔交易
transaction = {
    'id': 'TXN001',
    'risk_score': 45,
    'amount': 5000,
    'user_id': 'USER123'
}
env.set_transaction(transaction)

# 让Agent工作
behavior_agent.run(env)
background_agent.run(env)
decision_agent.run(env)

# 让Agent之间交流
behavior_agent.communicate(decision_agent, "这笔交易的行为模式有些异常")
background_agent.communicate(decision_agent, "用户背景检查通过")

# 再次让决策Agent工作，这次它会处理收到的消息
decision_agent.run(env)

这个简单的AI Agent实现展示了Agent的基本工作原理：感知环境、推理决策、执行行动、学习、交流。

多智能体协同：让AI小助手一起合作

现在，让我们看看如何让多个AI Agent一起协作。在多智能体系统中，每个Agent都有自己的专长，它们通过交流合作，完成单个Agent无法完成的任务。

多智能体协同有几种常见的模式：

1. 中心化协作：有一个"领导"Agent，负责协调其他Agent
2. 分布式协作：所有Agent平等地交流合作，没有明显的领导
3. 混合模式：结合了中心化和分布式的特点

让我们用Python实现一个简单的多智能体协同风控系统：

import random
from typing import List, Dict, Any

# 首先，定义一些基础类

class Message:
    """消息类"""
    def __init__(self, sender, receiver, content, msg_type="information"):
        self.sender = sender
        self.receiver = receiver
        self.content = content
        self.msg_type = msg_type  # information, request, response
        self.timestamp = time.time()

class Environment:
    """环境类"""
    def __init__(self):
        self.transactions = {}
        self.global_state = {}
    
    def add_transaction(self, transaction):
        """添加交易"""
        txn_id = transaction['id']
        self.transactions[txn_id] = transaction
        return txn_id
    
    def get_transaction(self, txn_id):
        """获取交易"""
        return self.transactions.get(txn_id)
    
    def update_global_state(self, key, value):
        """更新全局状态"""
        self.global_state[key] = value

class BaseAIAgent:
    """AI Agent基类"""
    def __init__(self, name: str, agent_id: str):
        self.name = name
        self.agent_id = agent_id
        self.inbox: List[Message] = []
        self.outbox: List[Message] = []
        self.knowledge_base: Dict[str, Any] = {}
        self.active = True
    
    def receive_message(self, message: Message):
        """接收消息"""
        self.inbox.append(message)
    
    def send_message(self, message: Message):
        """发送消息"""
        self.outbox.append(message)
    
    def process_messages(self):
        """处理收到的消息"""
        processed = []
        for msg in self.inbox:
            result = self._handle_message(msg)
            processed.append((msg, result))
        self.inbox = []  # 清空收件箱
        return processed
    
    def _handle_message(self, message: Message):
        """处理单个消息（子类重写）"""
        pass
    
    def perceive(self, environment: Environment):
        """感知环境（子类重写）"""
        pass
    
    def reason(self):
        """推理（子类重写）"""
        pass
    
    def act(self, environment: Environment):
        """行动（子类重写）"""
        pass
    
    def learn(self, experience: Dict[str, Any]):
        """学习（子类重写）"""
        pass
    
    def run(self, environment: Environment):
        """运行Agent"""
        if not self.active:
            return
        
        print(f"\n{'='*60}")
        print(f"{self.name} 开始运行")
        print(f"{'='*60}")
        
        # 1. 感知环境
        self.perceive(environment)
        
        # 2. 处理消息
        self.process_messages()
        
        # 3. 推理
        decisions = self.reason()
        
        # 4. 行动
        results = self.act(environment)
        
        # 5. 学习
        experience = {'decisions': decisions, 'results': results}
        self.learn(experience)
        
        return decisions, results

# 现在，定义一些具体的风控Agent

class BehaviorAnalysisAgent(BaseAIAgent):
    """行为分析Agent"""
    def __init__(self, name: str, agent_id: str):
        super().__init__(name, agent_id)
        self.current_transaction = None
        self.behavior_analysis_result = None
    
    def perceive(self, environment: Environment):
        """感知环境 - 获取交易信息并分析行为"""
        print(f"{self.name} 正在感知交易环境...")
        # 假设有一个交易ID需要分析
        txn_id = self.knowledge_base.get('current_txn_id')
        if txn_id:
            self.current_transaction = environment.get_transaction(txn_id)
            print(f"{self.name} 获取到交易信息: {self.current_transaction}")
    
    def _handle_message(self, message: Message):
        """处理消息"""
        print(f"{self.name} 处理来自 {message.sender.name} 的消息: {message.content}")
        if message.msg_type == "request" and "analyze_behavior" in message.content:
            txn_id = message.content.get('txn_id')
            self.knowledge_base['current_txn_id'] = txn_id
            return "收到分析请求"
        return "消息已处理"
    
    def reason(self):
        """推理 - 分析交易行为是否异常"""
        if not self.current_transaction:
            return {"status": "no_transaction"}
        
        print(f"{self.name} 正在分析交易行为...")
        
        # 模拟行为分析
        amount = self.current_transaction.get('amount', 0)
        is_first = self.current_transaction.get('is_first', False)
        location = self.current_transaction.get('location', '')
        usual_location = self.current_transaction.get('usual_location', '')
        
        risk_factors = []
        if amount > 10000:
            risk_factors.append("大额交易")
        if is_first:
            risk_factors.append("首次交易")
        if location != usual_location:
            risk_factors.append("异常位置")
        
        risk_score = len(risk_factors) * 30  # 每个风险因素30分
        self.behavior_analysis_result = {
            'risk_score': risk_score,
            'risk_factors': risk_factors,
            'analysis': '行为分析完成'
        }
        
        print(f"{self.name} 行为分析结果: {self.behavior_analysis_result}")
        return self.behavior_analysis_result
    
    def act(self, environment: Environment):
        """行动 - 发送分析结果给其他Agent"""
        if not self.behavior_analysis_result:
            return {"status": "no_action"}
        
        print(f"{self.name} 正在发送行为分析结果...")
        # 假设有一个决策Agent需要这个结果
        decision_agent = self.knowledge_base.get('decision_agent')
        if decision_agent:
            msg = Message(
                sender=self,
                receiver=decision_agent,
                content={
                    'type': 'behavior_analysis',
                    'result': self.behavior_analysis_result,
                    'txn_id': self.current_transaction.get('id')
                },
                msg_type="information"
            )
            self.send_message(msg)
        
        return {"status": "analysis_sent"}
    
    def learn(self, experience: Dict[str, Any]):
        """学习 - 简单记录经验"""
        print(f"{self.name} 正在记录经验...")
        if 'behavior_history' not in self.knowledge_base:
            self.knowledge_base['behavior_history'] = []
        self.knowledge_base['behavior_history'].append(experience)

class BackgroundCheckAgent(BaseAIAgent):
    """背景调查Agent"""
    def __init__(self, name: str, agent_id: str):
        super().__init__(name, agent_id)
        self.current_user = None
        self.background_check_result = None
    
    def perceive(self, environment: Environment):
        """感知环境 - 获取用户信息"""
        print(f"{self.name} 正在感知用户环境...")
        user_id = self.knowledge_base.get('current_user_id')
        if user_id:
            # 模拟从数据库获取用户信息
            self.current_user = {
                'id': user_id,
                'credit_score': random.randint(300, 850),
                'account_age_days': random.randint(1, 3650),
                'previous_fraud': random.choice([True, False]),
                'income_level': random.choice(['low', 'medium', 'high'])
            }
            print(f"{self.name} 获取到用户信息: {self.current_user}")
    
    def _handle_message(self, message: Message):
        """处理消息"""
        print(f"{self.name} 处理来自 {message.sender.name} 的消息: {message.content}")
        if message.msg_type == "request" and "check_background" in message.content:
            user_id = message.content.get('user_id')
            self.knowledge_base['current_user_id'] = user_id
            return "收到背景调查请求"
        return "消息已处理"
    
    def reason(self):
        """推理 - 评估用户背景"""
        if not self.current_user:
            return {"status": "no_user"}
        
        print(f"{self.name} 正在调查用户背景...")
        
        # 模拟背景评估
        credit_score = self.current_user.get('credit_score', 500)
        previous_fraud = self.current_user.get('previous_fraud', False)
        account_age = self.current_user.get('account_age_days', 1)
        
        risk_factors = []
        risk_score = 0
        
        if credit_score < 600:
            risk_factors.append("信用分数低")
            risk_score += 40
        
        if previous_fraud:
            risk_factors.append("有欺诈历史")
            risk_score += 50
        
        if account_age < 30:
            risk_factors.append("新账户")
            risk_score += 20
        
        self.background_check_result = {
            'risk_score': risk_score,
            'risk_factors': risk_factors,
            'credit_score': credit_score,
            'analysis': '背景调查完成'
        }
        
        print(f"{self.name} 背景调查结果: {self.background_check_result}")
        return self.background_check_result
    
    def act(self, environment: Environment):
        """行动 - 发送背景调查结果"""
        if not self.background_check_result:
            return {"status": "no_action"}
        
        print(f"{self.name} 正在发送背景调查结果...")
        decision_agent = self.knowledge_base.get('decision_agent')
        if decision_agent:
            msg = Message(
                sender=self,
                receiver=decision_agent,
                content={
                    'type': 'background_check',
                    'result': self.background_check_result,
                    'user_id': self.current_user.get('id')
                },
                msg_type="information"
            )
            self.send_message(msg)
        
        return {"status": "check_result_sent"}
    
    def learn(self, experience: Dict[str, Any]):
        """学习"""
        print(f"{self.name} 正在记录经验...")
        if 'background_history' not in self.knowledge_base:
            self.knowledge_base['background_history'] = []
        self.knowledge_base['background_history'].append(experience)

class DecisionAgent(BaseAIAgent):
    """决策Agent"""
    def __init__(self, name: str, agent_id: str):
        super().__init__(name, agent_id)
        self.current_transaction = None
        self.behavior_result = None
        self.background_result = None
        self.final_decision = None
    
    def perceive(self, environment: Environment):
        """感知环境"""
        print(f"{self.name} 正在感知整体环境...")
        txn_id = self.knowledge_base.get('current_txn_id')
        if txn_id:
            self.current_transaction = environment.get_transaction(txn_id)
    
    def _handle_message(self, message: Message):
        """处理消息 - 收集其他Agent的分析结果"""
        print(f"{self.name} 处理来自 {message.sender.name} 的消息: {message.content}")
        content = message.content
        if content.get('type') == 'behavior_analysis':
            self.behavior_result = content.get('result')
            print(f"{self.name} 收到行为分析结果")
        elif content.get('type') == 'background_check':
            self.background_result = content.get('result')
            print(f"{self.name} 收到背景调查结果")
        return "消息已接收"
    
    def reason(self):
        """推理 - 综合所有信息做出决策"""
        if not self.current_transaction:
            return {"status": "no_transaction"}
        
        print(f"{self.name} 正在综合分析所有信息...")
        
        # 收集所有风险分数
        total_risk = 0
        all_risk_factors = []
        
        if self.behavior_result:
            total_risk += self.behavior_result.get('risk_score', 0)
            all_risk_factors.extend(self.behavior_result.get('risk_factors', []))
        
        if self.background_result:
            total_risk += self.background_result.get('risk_score', 0)
            all_risk_factors.extend(self.background_result.get('risk_factors', []))
        
        # 做出决策
        if total_risk >= 100:
            decision = "拒绝交易"
            confidence = 0.9
        elif total_risk >= 50:
            decision = "人工审核"
            confidence = 0.7
        else:
            decision = "通过交易"
            confidence = 0.9
        
        self.final_decision = {
            'decision': decision,
            'confidence': confidence,
            'total_risk': total_risk,
            'risk_factors': all_risk_factors,
            'txn_id': self.current_transaction.get('id')
        }
        
        print(f"{self.name} 最终决策: {self.final_decision}")
        return self.final_decision
    
    def act(self, environment: Environment):
        """行动 - 执行决策并更新环境"""
        if not self.final_decision:
            return {"status": "no_decision"}
        
        print(f"{self.name} 正在执行决策: {self.final_decision['decision']}")
        
        # 更新环境中的交易状态
        txn_id = self.final_decision['txn_id']
        transaction = environment.get_transaction(txn_id)
        if transaction:
            transaction['status'] = self.final_decision['decision']
            transaction['risk_score'] = self.final_decision['total_risk']
        
        return {"status": "decision_executed", "decision": self.final_decision}
    
    def learn(self, experience: Dict[str, Any]):
        """学习"""
        print(f"{self.name} 正在记录决策经验...")
        if 'decision_history' not in self.knowledge_base:
            self.knowledge_base['decision_history'] = []
        self.knowledge_base['decision_history'].append(experience)

class MultiAgentSystem:
    """多智能体系统"""
    def __init__(self):
        self.agents: Dict[str, BaseAIAgent] = {}
        self.environment = Environment()
        self.message_broker = []  # 消息代理
    
    def register_agent(self, agent: BaseAIAgent):
        """注册Agent"""
        self.agents[agent.agent_id] = agent
        print(f"已注册Agent: {agent.name} ({agent.agent_id})")
    
    def deliver_messages(self):
        """投递消息"""
        # 收集所有Agent的发件箱
        all_messages = []
        for agent in self.agents.values():
            all_messages.extend(agent.outbox)
            agent.outbox = []  # 清空发件箱
        
        # 投递消息
        for msg in all_messages:
            if msg.receiver.agent_id in self.agents:
                msg.receiver.receive_message(msg)
                print(f"消息已从 {msg.sender.name} 投递到 {msg.receiver.name}")
    
    def run_agents(self):
        """运行所有Agent"""
        results = {}
        for agent_id, agent in self.agents.items():
            decisions, agent_results = agent.run(self.environment)
            results[agent_id] = {
                'decisions': decisions,
                'results': agent_results
            }
        return results
    
    def process_transaction(self, transaction):
        """处理一笔交易"""
        print(f"\n{'='*60}")
        print(f"开始处理交易: {transaction['id']}")
        print(f"{'='*60}")
        
        # 添加交易到环境
        self.environment.add_transaction(transaction)
        
        # 获取Agent引用
        behavior_agent = self.agents.get('behavior')
        background_agent = self.agents.get('background')
        decision_agent = self.agents.get('decision')
        
        # 设置Agent之间的关联
        if behavior_agent:
            behavior_agent.knowledge_base['decision_agent'] = decision_agent
            behavior_agent.knowledge_base['current_txn_id'] = transaction['id']
        
        if background_agent:
            background_agent.knowledge_base['decision_agent'] = decision_agent
            background_agent.knowledge_base['current_user_id'] = transaction['user_id']
        
        if decision_agent:
            decision_agent.knowledge_base['current_txn_id'] = transaction['id']
        
        # 第一轮运行 - 行为分析和背景调查
        print("\n>>> 第一轮：信息收集")
        self.run_agents()
        self.deliver_messages()
        
        # 给一点时间处理（实际系统中不需要）
        time.sleep(1)
        
        # 第二轮运行 - 决策
        print("\n>>> 第二轮：决策")
        results = self.run_agents()
        
        # 获取最终决策
        final_result = results.get('decision',