
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
一句话总结:AI Agent 是一种以 LLM 为"大脑"、以规划(Planning)为策略中枢、以记忆(Memory)为经验沉淀、以工具调用(Tool Use)为行动手段、以反思(Reflection)为进化机制的自主决策系统;在风控场景中,Agent 能够将原本需要资深分析师数小时完成的"告警研判→多维调查→证据链整理→处置建议"全流程,压缩到分钟级自动执行。
1. 概念定义(是什么)
1.1 Agent 的本质
AI Agent(智能体) 是一种以大语言模型(LLM)为核心推理引擎,能够自主感知环境、制定计划、调用工具、利用记忆、反思修正,并在多轮交互中完成复杂目标的系统。
与传统软件的对比:
| 维度 | 传统软件 | AI Agent |
|---|---|---|
| 输入处理 | 严格的结构化输入(API 参数、表单) | 自然语言理解,容忍模糊表达 |
| 决策逻辑 | 硬编码规则(if-else) | LLM 推理 + 上下文学习 |
| 执行能力 | 预定义函数调用 | 动态工具选择 + 参数填充 |
| 错误处理 | 抛出异常或返回错误码 | 自主重试、替代方案、向上求助 |
| 知识边界 | 代码中写死的业务知识 | 可检索外部知识库(RAG)、可记忆历史经验 |
| 适用场景 | 确定性流程 | 开放性、探索性、需要综合判断的任务 |
Agent 核心公式:
Agent = LLM(大脑)+ Planning(规划)+ Memory(记忆)+ Tool Use(工具)+ Reflection(反思)
1.2 类比理解
类比:资深风控调查分析师
- LLM = 分析师的大脑:理解自然语言、具备金融风控领域知识、能推理判断
- Planning = 分析师的办案思路:接到"用户 A 账户异常"的告警后,先查交易流水,再查设备指纹,然后关联图谱,最后下结论——不是随机查,是有策略地查
- Memory = 分析师的笔记本和案例库:笔记本记录本次调查的进展(短期记忆),案例库存着过去 1000 个类似案件的处理经验(长期记忆)
- Tool Use = 分析师调用的系统:查数据库、调交易接口、跑图谱算法、生成报告——分析师不会自己算,而是会"用工具"
- Reflection = 分析师的复盘习惯:发现初步结论有漏洞,回头重新检查证据链;或者发现自己查错了方向,及时调整策略
传统程序像一个"自动柜台机":按按钮出结果。Agent 像一个"真人分析师":理解问题、制定策略、调用资源、反思修正、给出建议。
1.3 为什么风控需要 Agent
风控调查的复杂性天然适合 Agent:
- 信息分散:一笔可疑交易涉及交易数据、用户画像、设备信息、IP 地理位置、关联账户、历史行为——信息散落在 6+ 个系统中
- 研判非结构化:不同分析师的研判逻辑不同,没有标准 SOP;资深分析师的"直觉"难以编码为规则
- 时效压力:重大风险事件(如盗号批量出金)需要在分钟级内完成调查并处置
- 知识沉淀难:分析师的实战经验流失严重,新人培养周期长(6-12 个月)
Agent 的价值在于:将专家的经验固化为可复用的自主工作流。
2. 核心原理与图解
2.1 ReAct 模式:推理与行动的闭环
ReAct(Reasoning + Acting)是 Agent 最经典的执行范式,由 Google 在 2022 年提出。核心思想是:LLM 不应该直接给答案,而是应该像人类一样"先思考、再行动、观察结果、再思考"。
ReAct 循环的四个角色:
| 角色 | 作用 | 示例 |
|---|---|---|
| Thought(思考) | 分析当前状况,制定下一步计划 | "我需要查交易记录" |
| Action(行动) | 调用工具,获取外部信息 | tradeQueryTool(userId=A) |
| Observation(观察) | 工具返回的结果 | "5 笔 9990 USDT 转出" |
| Final Answer(结论) | 循环终止时给出的最终答案 | "疑似 Structuring,建议冻结" |
为什么 ReAct 比直接 Prompt 有效?
- 分解复杂任务:将"调查可疑交易"分解为可执行的子步骤,降低每一步的认知负荷
- 利用外部工具扩展能力:LLM 本身不知道实时交易数据,但可以通过工具查询
- 可追溯的推理链:每一步 Thought 都记录在案,便于审计和调试
- 错误恢复能力:如果某步工具调用失败,可以在下一步 Thought 中调整策略
2.2 Function Calling:Agent 的"手"
Function Calling(工具调用)是 LLM 与外部世界交互的桥梁。现代 LLM(GPT-4、Claude、Gemini)原生支持根据用户意图自动选择并调用预定义的函数。
Function Calling 的三要素:
- 工具定义(Schema):用 JSON Schema 描述每个工具的"名字、用途、参数类型、必填项"
- 工具注册(Registry):Agent 启动时将工具定义注册到 LLM 的上下文
- 工具执行(Execution):LLM 输出
function_call指令后,Agent 负责解析参数、调用实际函数、返回结果
2.3 记忆体系:Agent 的"笔记"
Agent 的记忆分为三层,解决不同时间尺度的信息存储问题:
| 记忆类型 | 存储内容 | 技术实现 | 生命周期 |
|---|---|---|---|
| Short-Term | ReAct 循环中的完整对话历史 | LLM 上下文窗口 | 单次对话 |
| Working | 当前任务的中间状态(TODO 列表、已确认事实) | 结构化对象(Java Class) | 单次调查 |
| Long-Term | 历史案例、处置经验、规则知识 | 向量数据库 + 知识图谱 | 持久化 |
向量检索流程:
- 当前调查进展被 Embedding 为向量
- 在向量数据库中检索相似度最高的历史案例(如"Structuring 洗钱模式调查")
- 将历史案例的处置经验注入当前上下文,作为 Few-Shot 示例
2.4 反思机制:Agent 的"复盘"
反思(Reflection / Self-Correction)是 Agent 从错误中学习的关键能力。
两种反思策略:
-
内省反思(Internal Reflection):Agent 自己检查推理链,问自己:
- "我的结论是否过度推断?"
- "是否有其他解释可以说明这些证据?"
- "我是否忽略了某些反例?"
-
外部反思(External Reflection):引入更高层 Agent(如"督察 Agent")审查初级 Agent 的结论,或引入人类反馈(RLHF)。
2.5 多 Agent 协作架构
复杂风控调查通常需要多个专业 Agent 协作:
多 Agent 协作模式:
| 模式 | 描述 | 风控场景 |
|---|---|---|
| Orchestrator-Workers | 总调度 Agent 分解任务,Worker Agent 并行执行 | 复杂案件调查 |
| Peer-to-Peer | 多个平等 Agent 协商讨论 | 规则制定委员会模拟 |
| Hierarchical | 分层汇报,底层 Agent 处理细节,高层 Agent 决策 | 分级风控决策 |
| Competitive | 多个 Agent 提出不同方案,投票选择最优 | 模型与规则冲突时的仲裁 |
3. 语法详解与代码示例(怎么用)
3.1 核心 Agent 框架实现(Java + Spring Boot)
/**
* Agent 核心接口:所有风控 Agent 的基础契约
*/
public interface RiskAgent {
/** Agent 名称 */
String getName();
/** Agent 职责描述(用于 LLM 理解) */
String getDescription();
/** 执行调查任务 */
InvestigationResult investigate(InvestigationTask task);
/** 获取可用工具列表 */
List<ToolDefinition> getAvailableTools();
}
/**
* ReAct Agent 实现:推理-行动循环
*/
@Service
public class ReActRiskAgent implements RiskAgent {
@Autowired private LlmClient llmClient;
@Autowired private ToolRegistry toolRegistry;
@Autowired private VectorMemoryService memoryService;
@Autowired private MeterRegistry metrics;
private static final int MAX_ITERATIONS = 10;
private static final String SYSTEM_PROMPT_TEMPLATE = """
You are a senior risk investigation analyst at 大型加密货币交易所.
Your task is to investigate suspicious activities based on available tools.
You operate in a ReAct loop:
1. Thought: Analyze the current situation and plan next step
2. Action: Call one of the available tools with proper parameters
3. Observation: Review the tool result
4. Repeat until you have enough evidence to conclude
Available tools:
{tool_descriptions}
Rules:
- Always think step by step
- If evidence is insufficient, request more data via tools
- Confidence must be based on concrete evidence, not speculation
- For money laundering patterns, check: amount structuring, frequency, destination addresses
- Output final answer in JSON format with fields: conclusion, confidence, evidence_list, recommended_action
""";
@Override
public String getName() { return "RiskInvestigationAgent-v2"; }
@Override
public String getDescription() {
return "Investigates suspicious transactions by querying trade history, user profiles, and blacklists";
}
@Override
public InvestigationResult investigate(InvestigationTask task) {
Timer.Sample sample = Timer.start(metrics);
List<ReActStep> steps = new ArrayList<>();
// 1. 构建系统 Prompt(注入工具定义)
String toolDescriptions = toolRegistry.describeAllTools();
String systemPrompt = SYSTEM_PROMPT_TEMPLATE.replace("{tool_descriptions}", toolDescriptions);
// 2. 检索长期记忆:相似历史案例
List<HistoricalCase> similarCases = memoryService.findSimilarCases(
task.getUserId(), task.getAlertType(), 3);
String memoryContext = formatCasesAsFewShot(similarCases);
// 3. 初始化对话上下文
List<ChatMessage> messages = new ArrayList<>();
messages.add(ChatMessage.system(systemPrompt + "\n\nHistorical cases for reference:\n" + memoryContext));
messages.add(ChatMessage.user(buildUserQuery(task)));
// 4. ReAct 主循环
for (int i = 0; i < MAX_ITERATIONS; i++) {
// 4.1 调用 LLM 推理
LlmResponse response = llmClient.chat(messages);
String content = response.getContent();
// 4.2 解析 LLM 输出
if (content.contains("FINAL_ANSWER")) {
// 循环终止:给出最终结论
InvestigationResult result = parseFinalAnswer(content, task);
result.setSteps(steps);
// 归档到长期记忆
memoryService.archiveInvestigation(result);
sample.stop(metrics.timer("agent.investigation.duration",
"alert_type", task.getAlertType(),
"outcome", result.getConclusion()));
return result;
}
// 4.3 解析 Thought + Action
ThoughtActionPair pair = parseThoughtAction(content);
steps.add(new ReActStep(i, pair.thought(), pair.action(), null));
// 4.4 执行工具调用
ToolResult toolResult = executeTool(pair.action());
steps.get(steps.size() - 1).setObservation(toolResult.summary());
// 4.5 将 Observation 追加到上下文
messages.add(ChatMessage.assistant(content));
messages.add(ChatMessage.user("Observation: " + toolResult.getRawOutput()));
metrics.counter("agent.tool_call", "tool", pair.action().toolName()).increment();
}
// 达到最大迭代次数仍未得出结论
return InvestigationResult.timeout(steps);
}
/**
* 执行工具调用
*/
private ToolResult executeTool(ToolAction action) {
ToolDefinition tool = toolRegistry.findTool(action.toolName());
if (tool == null) {
return ToolResult.error("Tool not found: " + action.toolName());
}
try {
// 参数校验与类型转换
Map<String, Object> validatedArgs = validateAndConvertArgs(tool, action.args());
// 实际调用(反射或 Spring Bean)
Object result = tool.execute(validatedArgs);
return ToolResult.success(result);
} catch (Exception e) {
log.error("Tool execution failed: {}", action.toolName(), e);
return ToolResult.error(e.getMessage());
}
}
/**
* 格式化历史案例为 Few-Shot 示例
*/
private String formatCasesAsFewShot(List<HistoricalCase> cases) {
StringBuilder sb = new StringBuilder();
for (HistoricalCase c : cases) {
sb.append("Case: ").append(c.getCaseId()).append("\n")
.append("Alert: ").append(c.getAlertType()).append("\n")
.append("Evidence: ").append(c.getEvidenceSummary()).append("\n")
.append("Conclusion: ").append(c.getConclusion()).append("\n\n");
}
return sb.toString();
}
private String buildUserQuery(InvestigationTask task) {
return String.format("""
Investigation Task:
- User ID: %s
- Alert Type: %s
- Alert Time: %s
- Trigger Event: %s
- Priority: %s
Please investigate this case step by step.
""",
task.getUserId(), task.getAlertType(), task.getAlertTime(),
task.getTriggerEvent(), task.getPriority());
}
}
/**
* ReAct 单步记录
*/
public record ReActStep(
int iteration,
String thought,
ToolAction action,
String observation
) {}
/**
* 工具定义:可执行的外部能力
*/
public interface ToolDefinition {
String getName();
String getDescription();
Map<String, Object> getParameterSchema(); // JSON Schema
Object execute(Map<String, Object> args);
}3.2 工具注册中心与风控工具实现
/**
* 工具注册中心:管理 Agent 可调用的所有工具
*/
@Component
public class ToolRegistry {
private final Map<String, ToolDefinition> tools = new ConcurrentHashMap<>();
@PostConstruct
public void init() {
// 注册所有风控工具
register(new QueryTradeHistoryTool());
register(new CheckBlacklistTool());
register(new QueryUserProfileTool());
register(new GraphAssociationTool());
register(new GenerateReportTool());
register(new RiskScoreQueryTool());
}
public void register(ToolDefinition tool) {
tools.put(tool.getName(), tool);
}
public ToolDefinition findTool(String name) {
return tools.get(name);
}
/**
* 生成工具描述文本(注入 LLM Prompt)
*/
public String describeAllTools() {
StringBuilder sb = new StringBuilder();
for (ToolDefinition tool : tools.values()) {
sb.append(String.format("""
Tool: %s
Description: %s
Parameters: %s
\n""",
tool.getName(),
tool.getDescription(),
JsonUtils.toJson(tool.getParameterSchema())
));
}
return sb.toString();
}
}
/**
* 工具 1:交易历史查询
*/
@Component
public class QueryTradeHistoryTool implements ToolDefinition {
@Autowired private TradeRepository tradeRepository;
@Override public String getName() { return "query_trade_history"; }
@Override public String getDescription() {
return "Query user's recent transaction history with filters";
}
@Override
public Map<String, Object> getParameterSchema() {
return Map.of(
"type", "object",
"properties", Map.of(
"user_id", Map.of("type", "string", "description", "User ID to query"),
"hours", Map.of("type", "integer", "description", "Lookback hours, max 168"),
"currency", Map.of("type", "string", "description", "Filter by currency, e.g., 'USDT'"),
"min_amount", Map.of("type", "number", "description", "Minimum transaction amount")
),
"required", List.of("user_id", "hours")
);
}
@Override
public Object execute(Map<String, Object> args) {
String userId = (String) args.get("user_id");
int hours = ((Number) args.get("hours")).intValue();
String currency = (String) args.getOrDefault("currency", null);
BigDecimal minAmount = args.containsKey("min_amount")
? new BigDecimal(args.get("min_amount").toString())
: null;
LocalDateTime startTime = LocalDateTime.now().minusHours(hours);
List<Transaction> transactions = tradeRepository.findByUserIdAndTimeRange(
userId, startTime, LocalDateTime.now());
// 应用额外过滤
return transactions.stream()
.filter(t -> currency == null || t.getCurrency().equals(currency))
.filter(t -> minAmount == null || t.getAmount().compareTo(minAmount) >= 0)
.map(t -> Map.of(
"tx_id", t.getTxId(),
"amount", t.getAmount(),
"currency", t.getCurrency(),
"type", t.getType(),
"to_address", t.getToAddress(),
"timestamp", t.getTimestamp().toString(),
"status", t.getStatus()
))
.toList();
}
}
/**
* 工具 2:黑名单地址查询
*/
@Component
public class CheckBlacklistTool implements ToolDefinition {
@Autowired private BlacklistService blacklistService;
@Override public String getName() { return "check_blacklist"; }
@Override public String getDescription() {
return "Check if cryptocurrency addresses are in the blacklist";
}
@Override
public Map<String, Object> getParameterSchema() {
return Map.of(
"type", "object",
"properties", Map.of(
"addresses", Map.of(
"type", "array",
"items", Map.of("type", "string"),
"description", "List of crypto addresses to check"
)
),
"required", List.of("addresses")
);
}
@Override
public Object execute(Map<String, Object> args) {
@SuppressWarnings("unchecked")
List<String> addresses = (List<String>) args.get("addresses");
return addresses.stream().map(addr -> {
BlacklistCheckResult result = blacklistService.check(addr);
return Map.of(
"address", addr,
"is_blacklisted", result.isBlacklisted(),
"risk_level", result.getRiskLevel(),
"list_source", result.getSource(),
"added_date", result.getAddedDate()
);
}).toList();
}
}
/**
* 工具 3:关联图谱查询
*/
@Component
public class GraphAssociationTool implements ToolDefinition {
@Autowired private Neo4jClient neo4jClient;
@Override public String getName() { return "query_association_graph"; }
@Override public String getDescription() {
return "Query the relationship graph between users, devices, and addresses";
}
@Override
public Map<String, Object> getParameterSchema() {
return Map.of(
"type", "object",
"properties", Map.of(
"center_node_id", Map.of("type", "string"),
"node_type", Map.of("type", "string", "enum", List.of("USER", "DEVICE", "ADDRESS", "IP")),
"depth", Map.of("type", "integer", "description", "Graph traversal depth, 1-3")
),
"required", List.of("center_node_id", "node_type")
);
}
@Override
public Object execute(Map<String, Object> args) {
String nodeId = (String) args.get("center_node_id");
String nodeType = (String) args.get("node_type");
int depth = ((Number) args.getOrDefault("depth", 2)).intValue();
String cypher = String.format("""
MATCH path = (center:%s {id: $nodeId})-[:USED_BY|TRANSFER_TO|LOGGED_FROM*1..%d]-(neighbor)
RETURN center, neighbor, relationships(path) as rels
LIMIT 50
""", nodeType, depth);
return neo4jClient.query(cypher)
.bindAll(Map.of("nodeId", nodeId))
.fetchAs(Map.class)
.all();
}
}3.3 向量记忆服务:长期记忆与案例检索
/**
* 向量记忆服务:将调查案例 Embedding 后存储,支持相似案例检索
*/
@Service
public class VectorMemoryService {
@Autowired private EmbeddingClient embeddingClient;
@Autowired private MilvusClient milvusClient;
@Autowired private ObjectMapper objectMapper;
private static final String COLLECTION_NAME = "risk_investigation_cases";
private static final int VECTOR_DIM = 1536; // OpenAI text-embedding-3-small
/**
* 归档调查案例到向量数据库
*/
public void archiveInvestigation(InvestigationResult result) {
try {
// 1. 构建案例文本摘要
String caseSummary = buildCaseSummary(result);
// 2. 生成 Embedding
List<Float> embedding = embeddingClient.embed(caseSummary);
// 3. 写入 Milvus
JsonObject row = new JsonObject();
row.addProperty("case_id", result.getCaseId());
row.addProperty("user_id", result.getUserId());
row.addProperty("alert_type", result.getAlertType());
row.addProperty("conclusion", result.getConclusion());
row.addProperty("evidence_json", objectMapper.writeValueAsString(result.getEvidenceList()));
row.addProperty("recommended_action", result.getRecommendedAction());
row.add("embedding", JsonUtils.toJsonArray(embedding));
row.addProperty("archive_time", System.currentTimeMillis());
milvusClient.insert(InsertParam.newBuilder()
.withCollectionName(COLLECTION_NAME)
.withRows(List.of(row))
.build());
} catch (Exception e) {
log.error("Failed to archive investigation case: {}", result.getCaseId(), e);
}
}
/**
* 检索相似历史案例
*/
public List<HistoricalCase> findSimilarCases(String userId, String alertType, int topK) {
// 1. 构建查询文本
String queryText = String.format("Risk investigation case: alert_type=%s, user_behavior=suspicious", alertType);
// 2. 生成查询 Embedding
List<Float> queryVector = embeddingClient.embed(queryText);
// 3. 向量检索
SearchResults results = milvusClient.search(SearchParam.newBuilder()
.withCollectionName(COLLECTION_NAME)
.withVectors(List.of(queryVector))
.withVectorFieldName("embedding")
.withTopK(topK)
.withMetricType(MetricType.COSINE)
.withParams("{\"nprobe\": 10}")
.build());
// 4. 组装结果
return results.getResults().stream()
.map(this::convertToHistoricalCase)
.filter(Objects::nonNull)
.collect(Collectors.toList());
}
/**
* 构建案例文本摘要(用于 Embedding)
*/
private String buildCaseSummary(InvestigationResult result) {
StringBuilder sb = new StringBuilder();
sb.append("Investigation Case: ").append(result.getAlertType()).append("\n")
.append("Conclusion: ").append(result.getConclusion()).append("\n")
.append("Confidence: ").append(result.getConfidence()).append("\n");
for (Evidence evidence : result.getEvidenceList()) {
sb.append("Evidence: ").append(evidence.getDescription()).append("\n");
}
sb.append("Action: ").append(result.getRecommendedAction());
return sb.toString();
}
}3.4 多 Agent 协作:总调度 + 专业 Worker
/**
* 总调度 Agent:复杂案件分解与结果汇总
*/
@Service
public class OrchestratorAgent implements RiskAgent {
@Autowired private LlmClient llmClient;
@Autowired private ApplicationContext applicationContext;
private static final String ORCHESTRATOR_PROMPT = """
You are the lead investigator of the Risk Investigation Team.
Your role is to:
1. Analyze the incoming alert and break it down into sub-investigations
2. Dispatch tasks to specialist agents
3. Review their findings and resolve conflicts
4. Produce a final comprehensive report
Specialist agents available:
- TransactionAnalyst: Analyzes transaction patterns, frequencies, amounts
- UserProfiler: Investigates user KYC, history, behavior baseline
- GraphAnalyst: Traces fund flows, device sharing, IP clustering
- ReportWriter: Compiles findings into structured reports
Output your plan as JSON:
{
"plan": [
{"agent": "TransactionAnalyst", "task": "...", "priority": 1},
{"agent": "UserProfiler", "task": "...", "priority": 2}
],
"reasoning": "Why this plan?"
}
""";
@Override
public InvestigationResult investigate(InvestigationTask task) {
// 1. 制定调查计划
InvestigationPlan plan = createPlan(task);
// 2. 并行调度 Worker Agent
List<InvestigationResult> subResults = plan.getSteps().stream()
.map(step -> CompletableFuture.supplyAsync(() -> {
RiskAgent worker = getWorkerAgent(step.getAgentName());
InvestigationTask subTask = new InvestigationTask(
task.getCaseId(), task.getUserId(),
step.getTaskDescription(), task.getPriority()
);
return worker.investigate(subTask);
}))
.toList()
.stream()
.map(CompletableFuture::join)
.toList();
// 3. 冲突检测与仲裁
List<Conflict> conflicts = detectConflicts(subResults);
if (!conflicts.isEmpty()) {
subResults = arbitrateConflicts(conflicts, subResults);
}
// 4. 汇总生成最终报告
return synthesizeReport(task, plan, subResults);
}
private InvestigationPlan createPlan(InvestigationTask task) {
String planJson = llmClient.chat(List.of(
ChatMessage.system(ORCHESTRATOR_PROMPT),
ChatMessage.user(String.format("""
Alert: %s
User: %s
Trigger: %s
Please create an investigation plan.
""", task.getAlertType(), task.getUserId(), task.getTriggerEvent()))
)).getContent();
return JsonUtils.fromJson(planJson, InvestigationPlan.class);
}
private List<Conflict> detectConflicts(List<InvestigationResult> results) {
List<Conflict> conflicts = new ArrayList<>();
// 示例冲突:交易分析 Agent 说"正常",图谱分析 Agent 说"高风险"
Optional<InvestigationResult> txnResult = results.stream()
.filter(r -> r.getAgentName().equals("TransactionAnalyst")).findFirst();
Optional<InvestigationResult> graphResult = results.stream()
.filter(r -> r.getAgentName().equals("GraphAnalyst")).findFirst();
if (txnResult.isPresent() && graphResult.isPresent()) {
if (txnResult.get().getRiskLevel() == RiskLevel.LOW
&& graphResult.get().getRiskLevel() == RiskLevel.HIGH) {
conflicts.add(new Conflict(
"Risk assessment mismatch",
txnResult.get().getAgentName(),
graphResult.get().getAgentName(),
"Txn: LOW, Graph: HIGH"
));
}
}
return conflicts;
}
private List<InvestigationResult> arbitrateConflicts(List<Conflict> conflicts,
List<InvestigationResult> results) {
// 仲裁逻辑:图谱证据权重更高(关联欺诈更难伪造)
for (Conflict conflict : conflicts) {
log.warn("Conflict detected: {}", conflict.getDescription());
// 实际场景中可引入人类审核或更高层 Agent
}
return results;
}
private InvestigationResult synthesizeReport(InvestigationTask task,
InvestigationPlan plan,
List<InvestigationResult> subResults) {
String synthesisPrompt = String.format("""
As lead investigator, synthesize the following sub-investigation results into a final report.
Case ID: %s
User: %s
Alert Type: %s
Sub-investigations:
%s
Produce a final report with:
- executive_summary (2-3 sentences)
- risk_level (LOW/MEDIUM/HIGH/CRITICAL)
- confidence_score (0-1)
- key_evidence (bullet points)
- recommended_action
- uncertainty_notes (what remains unknown)
""",
task.getCaseId(), task.getUserId(), task.getAlertType(),
formatSubResults(subResults));
String reportJson = llmClient.chat(List.of(
ChatMessage.system("You are a senior risk investigation report writer."),
ChatMessage.user(synthesisPrompt)
)).getContent();
return JsonUtils.fromJson(reportJson, InvestigationResult.class)
.withAgentName(getName())
.withSubResults(subResults);
}
private RiskAgent getWorkerAgent(String name) {
return applicationContext.getBean(name, RiskAgent.class);
}
// ... getName, getDescription, getAvailableTools ...
}3.5 LLM 客户端:支持 Function Calling 的通用封装
/**
* LLM 客户端:封装 OpenAI / Claude 的 API 调用,统一处理 Function Calling
*/
@Service
public class OpenAiLlmClient implements LlmClient {
@Value("${openai.api-key}")
private String apiKey;
@Value("${openai.model:gpt-4-turbo-preview}")
private String model;
private final OpenAiService openAiService;
private final ObjectMapper objectMapper;
public OpenAiLlmClient() {
this.openAiService = new OpenAiService(apiKey, Duration.ofSeconds(60));
this.objectMapper = new ObjectMapper();
}
@Override
public LlmResponse chat(List<ChatMessage> messages, List<ToolDefinition> tools) {
List<ChatCompletionMessage> completionMessages = messages.stream()
.map(this::toCompletionMessage)
.toList();
// 构建 tools 参数(Function Calling)
List<Tool> functionTools = tools.stream()
.map(tool -> new Tool("function", new FunctionDefinition(
tool.getName(),
tool.getDescription(),
objectMapper.valueToTree(tool.getParameterSchema())
)))
.toList();
ChatCompletionRequest request = ChatCompletionRequest.builder()
.model(model)
.messages(completionMessages)
.tools(functionTools)
.toolChoice("auto") // 让模型自动决定是否调用工具
.temperature(0.2) // 低温度,更确定性
.maxTokens(2000)
.build();
ChatCompletionResult result = openAiService.createChatCompletion(request);
ChatCompletionChoice choice = result.getChoices().get(0);
// 处理 Function Calling 响应
if (choice.getMessage().getToolCalls() != null
&& !choice.getMessage().getToolCalls().isEmpty()) {
ToolCall toolCall = choice.getMessage().getToolCalls().get(0);
return LlmResponse.toolCall(
toolCall.getFunction().getName(),
toolCall.getFunction().getArguments()
);
}
return LlmResponse.text(choice.getMessage().getContent());
}
}
/**
* LLM 响应封装
*/
public record LlmResponse(
ResponseType type,
String content,
String toolName,
String toolArguments
) {
public static LlmResponse text(String content) {
return new LlmResponse(ResponseType.TEXT, content, null, null);
}
public static LlmResponse toolCall(String name, String args) {
return new LlmResponse(ResponseType.TOOL_CALL, null, name, args);
}
public enum ResponseType { TEXT, TOOL_CALL }
}4. 业界案例
4.1 Microsoft Security Copilot:AI 辅助安全调查
Microsoft Security Copilot 是 Agent 在安全/风控领域的标杆产品,核心能力是将原本需要数小时的安全事件调查压缩到分钟级。
核心架构:
- Orchestrator:接收安全告警(如"可疑登录"),自动分解调查任务
- Skill Set(工具集):
- Microsoft Sentinel(SIEM)查询
- Microsoft Defender(EDR)终端数据
- Microsoft Entra(身份管理)
- 威胁情报图谱(MSTIC)
- Memory:每个调查会话的上下文、历史查询、已确认事实
典型工作流:
- 分析师输入:"调查用户 [email protected] 的可疑活动"
- Copilot 自动执行:
- 查询 Entra ID:最近登录地点、设备、MFA 状态
- 查询 Sentinel:该用户触发的所有告警
- 查询 Defender:该设备的进程、网络连接
- 威胁情报:关联 IP 是否在已知 C2 列表
- 输出:结构化报告 + 攻击链时间线 + 建议的遏制措施
技术亮点:
- Prompt Chain 优化:将复杂调查分解为 10-20 个 Prompt 链,每个链有明确的输入输出契约
- 证据溯源:每个结论都附带"证据来源"链接,可点击跳转到原始日志
- 人类在环(Human-in-the-loop):关键处置(如禁用账户)需要人类确认,Agent 只负责调查和推荐
踩过的坑:
- Token 成本爆炸:早期版本每次调查消耗 50K+ Token,成本过高。解决方案:引入本地小模型(Phi-2)做初步筛选,只有复杂 case 才调用 GPT-4
- 幻觉问题:LLM 有时会"编造"不存在的攻击链。解决方案:所有结论必须绑定原始查询结果(Observation),LLM 只能基于已有证据推理
4.2 LangGraph:Multi-Agent 框架的工程实践
LangGraph 是 LangChain 团队推出的多 Agent 编排框架,被广泛应用于复杂风控场景的 Agent 构建。
核心设计:
- Graph 状态机:Agent 的执行不是线性循环,而是有向图(State Graph),每个节点是一个 Agent 或工具,边是状态转移条件
- 持久化状态:图的状态(Working Memory)可持久化到数据库,支持断点续查
- 人机交互节点:图执行到关键节点可暂停,等待人类输入
风控场景应用:
# LangGraph 调查工作流示例
from langgraph.graph import StateGraph
workflow = StateGraph(InvestigationState)
# 节点定义
workflow.add_node("triage", triage_agent) # 分级判断
workflow.add_node("investigate", react_agent) # 深度调查
workflow.add_node("human_review", human_review) # 人工审核
workflow.add_node("auto_dispose", auto_dispose) # 自动处置
# 边定义
workflow.add_edge("triage", "investigate")
workflow.add_conditional_edges(
"investigate",
lambda state: "human_review" if state.risk_level == "CRITICAL" else "auto_dispose"
)
workflow.add_edge("human_review", "auto_dispose")
# 编译执行
app = workflow.compile()
result = app.invoke({"alert_id": "ALT-12345"})关键经验:
- State Schema 严格化:每个节点的输入输出必须校验 Schema,防止 Agent 输出格式错误导致下游失败
- 循环限制:设置最大循环次数(如 10 次),防止 Agent 陷入无限循环
- 超时控制:每个节点设置超时(如 30s),超时后降级到预设策略
4.3 Palantir AIP:国防级风控 Agent 平台
Palantir(服务于 CIA、FBI 等情报机构)的 AIP 平台展示了 Agent 在高安全场景下的应用:
- Ontology 本体层:将企业数据抽象为"对象-属性-关系"的本体模型,Agent 的所有操作都基于本体而非原始 SQL
- Guardrails 护栏:
- 数据权限:Agent 只能访问用户有权限的数据
- 操作权限:Agent 不能执行写入操作(如冻结账户),只能推荐
- 审计追踪:Agent 的每个 Thought/Action 都记录到不可篡改的审计链
- Multi-Agent 军事化协作:
- 情报收集 Agent:从多源情报中筛选相关线索
- 关联分析 Agent:构建人员-事件-地点关联网络
- 报告生成 Agent:生成符合军方格式标准的情报简报
5. 业务场景对照与注意事项
5.1 AI 辅助风险调查 Agent 的完整场景
**场景**:凌晨 3 点,系统触发一条 CRITICAL 告警——用户 U12345 在过去 1 小时内进行了 20 笔 USDT 转出,每笔 4990,目标地址各不相同。
**传统流程(人工)**:
1. 分析师收到告警,登录 4 个系统查数据(15 分钟)
2. 手动比对黑名单、查交易流水、看用户历史(30 分钟)
3. 发现几个地址可疑,但不确定是否足够冻结账户(10 分钟)
4. 写报告、上报主管、等待审批(30 分钟)
5. 总计:85 分钟,可能错过最佳拦截窗口
**Agent 流程(自动化)**:
1. 告警自动接入 RiskInvestigationAgent(0 秒)
2. Agent 并行执行:
- 查询近 1 小时交易记录(发现 20 笔 4990 USDT → Structuring 模式)
- 查询目标地址黑名单(命中 8 个高风险地址)
- 查询用户画像(新注册 3 天,KYC 等级低)
- 关联图谱分析(目标地址与已知洗钱团伙有 2 度关联)
3. Agent 综合判断:风险等级 CRITICAL,置信度 0.94(2 分钟)
4. 生成结构化报告,附带完整证据链和时间线(1 分钟)
5. 自动提交给值班分析师确认,同时触发预冻结(资金锁定 24h)
6. 总计:3 分钟完成调查,分析师只需 30 秒确认
**Agent 不可替代人类的部分**:
- 涉及法律合规边界的处置(如永久封禁)
- 需要社会工程学判断的复杂 case(如"用户声称被盗号,但行为模式像内部员工")
- 新型攻击模式的首例识别(Agent 基于历史案例,对"从未见过"的模式可能漏报)5.2 Agent 在安全与合规方面的设计
| 风险点 | 防护措施 | 实现方式 |
|---|---|---|
| 越权数据访问 | 数据权限隔离 | Agent 调用工具时传递操作者身份,工具层做 RBAC 校验 |
| 恶意 Prompt 注入 | 输入消毒 | 用户输入经过正则过滤 + LLM 二次校验,防止"忽略之前指令"攻击 |
| 幻觉导致误封 | 人类在环确认 | CRITICAL 级别的处置建议必须经过人类确认,Agent 只有调查权 |
| Token 成本失控 | 预算限制 | 单次调查 Token 上限 50K,超过则降级到简化模式 |
| 推理链不可审计 | 完整日志 | 每个 Thought/Action/Observation 写入不可篡改的审计日志(WORM 存储) |
| 工具调用超时 | 熔断降级 | 单工具调用超时 10s,超时后 Agent 使用缓存或默认值继续推理 |
5.3 常见误区 vs 正确做法
❌ 误区 1:Agent 可以完全替代人工分析师
- 认为 Agent 上线后就不需要人了
✅ 正确做法:Agent 负责"信息收集和初步研判",人类负责"最终决策和复杂判断"。人机协作是最佳模式
❌ 误区 2:Agent 的工具权限越大越好
- 给 Agent 开放所有 API,包括资金冻结、账户删除
✅ 正确做法:Agent 的工具权限遵循最小权限原则。写入操作必须人类确认,Agent 只有"建议权"和"只读查询权"
❌ 误区 3:忽略 Token 成本,无限上下文
- 把完整交易流水(1 万条)全部塞进 Prompt
✅ 正确做法:工具层做数据聚合和摘要,只把聚合结果(如"20 笔,累计金额 99,800 USDT")给 LLM
❌ 误区 4:Agent 输出不可控,不做 Schema 约束
- LLM 输出自由文本,下游系统无法解析
✅ 正确做法:强制 JSON Schema 输出(OpenAI Function Calling / JSON Mode),做 Schema 校验,失败则重试
❌ 误区 5:单 Agent 处理所有任务
- 一个 Agent 既查交易、又查用户、又写报告
✅ 正确做法:Multi-Agent 分工,每个 Agent 专注一个领域,通过共享白板协作6. FAQ 与高频追问
Q1:Agent 和 RAG(检索增强生成)有什么区别?什么时候用 Agent,什么时候用 RAG?
答:Agent 和 RAG 不是互斥的,而是互补的:
| 维度 | RAG | Agent |
|---|---|---|
| 核心能力 | 从知识库检索相关信息,增强 LLM 回答 | 自主规划、调用工具、多步推理 |
| 适用场景 | "查知识"(如"什么是 Structuring 洗钱?") | "做任务"(如"调查这笔可疑交易") |
| 交互方式 | 单轮或少量轮次,被动响应 | 多轮主动探索,可自主决定下一步 |
| 工具调用 | 通常只有"检索"一个工具 | 可调用多种工具(查询、计算、写入) |
关系:Agent 内部通常包含 RAG(作为其中一个 Tool)。例如调查 Agent 在分析过程中,可能需要 RAG 检索" Structuring 洗钱的典型模式"作为参考知识。
选型建议:
- 如果任务有明确的步骤和确定性流程 → 用传统程序
- 如果任务需要查知识但不需要行动 → 用 RAG
- 如果任务需要探索、推理、调用多个系统 → 用 Agent
Q2:ReAct 模式为什么比直接给 LLM 所有数据更有效?
答:三个核心原因:
- 信息过载:直接给所有数据,LLM 的上下文窗口会被噪声淹没(如 1 万条交易记录),注意力分散。ReAct 让 LLM 按需索取数据,保持上下文精简
- 推理可追溯:ReAct 的每一步 Thought 都记录在案,形成"思维链"(Chain of Thought)。如果最终结论错误,可以定位是哪一步推理出了问题
- 工具扩展性:LLM 本身无法访问实时数据库或执行计算。ReAct 通过 Action 调用外部工具,突破了 LLM 的能力边界
追问:ReAct 的最大迭代次数设多少合适?
- 简单任务(单一查询):3-5 次
- 中等复杂度(多维度调查):8-10 次
- 复杂任务(关联图谱分析):10-15 次
- 超过 15 次通常意味着 Agent 陷入循环或任务过于复杂,应触发人工介入
Q3:Function Calling 和传统 API 调用有什么区别?为什么 LLM 需要专门的 Function Calling 机制?
答:Function Calling 不是替代传统 API,而是让 LLM 学会"选择"和"参数填充"。
传统 API 调用:
// 程序员硬编码调用哪个 API、传什么参数
blacklistService.check("0xabc123"); // 程序员知道要查黑名单Function Calling:
// LLM 自己决定:
// 1. 当前调查需要查什么?→ 黑名单
// 2. 查哪个地址?→ "0xabc123"
// 3. 参数怎么填?→ 从上下文中提取Function Calling 的独特价值:
- 参数结构化:LLM 输出的是 JSON,不是自然语言,下游系统可以直接解析执行
- 类型安全:通过 JSON Schema 约束参数类型,LLM 不会传字符串给数字字段
- 可组合:LLM 可以串联多个工具调用(先查交易 → 再查黑名单 → 再查图谱),形成工作流
Q4:多 Agent 协作中,Agent 之间怎么通信?共享什么状态?
答:常见的三种通信模式:
-
共享黑板(Shared Blackboard):
- 所有 Agent 读写同一块共享内存(如 Redis / 数据库)
- 优点:解耦,Agent 不需要知道其他 Agent 的存在
- 缺点:并发写入可能导致状态冲突
- 风控场景适用:调查进展白板(各 Agent 把发现写入,总调度读取)
-
消息传递(Message Passing):
- Agent 之间通过消息队列(Kafka / RabbitMQ)显式通信
- 优点:异步、可追踪、支持背压
- 缺点:延迟较高,需要设计消息格式
- 风控场景适用:跨团队 Agent 协作(如风控 Agent → 合规 Agent)
-
直接调用(Direct Invocation):
- Orchestrator 直接调用 Worker Agent 的方法(如 Java 方法调用)
- 优点:低延迟、强类型
- 缺点:耦合度高
- 风控场景适用:同一 JVM 内的 Agent 协作
共享状态设计:
- 最小共享:只共享"已确认的事实"(Facts),不共享原始推理过程
- 版本控制:共享状态带版本号,防止覆盖
- 权限隔离:Worker Agent 只能写入自己负责的区域,Orchestrator 有权读取全部
Q5:Agent 的"幻觉"问题在风控场景下怎么解决?
答:风控对准确性要求极高,需要多层防护:
- 事实 grounding:Agent 的每个结论必须绑定到原始数据(如"风险等级 HIGH,依据:交易记录 #TX12345,黑名单命中地址 0xabc")
- 证据链校验:下游系统解析 Agent 的输出时,验证引用的证据是否真实存在
- 置信度阈值:置信度 < 0.8 的结论标记为"待人工复核",不自动执行
- 对抗测试:定期用已知答案的 case 测试 Agent,检测幻觉率
- 人类在环(HITL):所有涉及资金处置的建议必须经过人类确认
// 证据链校验示例
public boolean validateEvidence(InvestigationResult result) {
for (Evidence evidence : result.getEvidenceList()) {
switch (evidence.getType()) {
case TRANSACTION -> {
if (!tradeRepository.existsById(evidence.getRefId())) {
return false; // 引用的交易不存在!
}
}
case BLACKLIST -> {
if (!blacklistService.isListed(evidence.getRefId())) {
return false; // 黑名单引用错误!
}
}
}
}
return true;
}Q6:Agent 的 Token 成本怎么控制?单次调查消耗太多 Token 怎么办?
答:Token 是 Agent 的主要运营成本,需要多层控制:
-
上下文压缩:
- 工具返回的原始数据在注入 Prompt 前做摘要(如 1000 条交易 → "20 笔,累计 99,800 USDT")
- 使用 LLM 做"上下文总结":每 5 轮对话后,将历史 Thought/Observation 压缩为 1 段摘要
-
模型分层:
- 简单任务(文本分类、摘要)→ GPT-3.5 / Claude Haiku(便宜 10x)
- 复杂推理(调查分析)→ GPT-4 / Claude Opus(只在关键节点调用)
-
Token 预算:
- 单次调查 Token 上限:Input 30K + Output 5K
- 超过预算则触发"精简模式"(只保留核心证据,丢弃细节)
-
缓存机制:
- 相同查询的结果缓存(如"查用户 A 的交易记录"在短时间内重复查询,直接返回缓存)
量化参考:
- 一次完整的轻度调查:~5K Input + ~1K Output ≈ $0.15(GPT-4 Turbo)
- 一次深度调查(10 轮 ReAct):~25K Input + ~5K Output ≈ $0.75
- 日处理 1000 次调查:~$500/天 → 需通过分层模型优化至 $100/天以下
7. 关联知识
| 文档 | 关联点 |
|---|---|
| F1 - LLM 风控应用 | Agent 依赖 LLM 作为推理引擎,F1 中的 Prompt 工程技巧直接适用于 Agent 的 Thought 生成 |
| F3 - Prompt Engineering | Agent 的 System Prompt 设计、Few-Shot 案例构造、输出结构化(JSON Schema) |
| E1 - 规则引擎设计 | Agent 可以调用规则引擎作为 Tool,将规则判定结果纳入调查证据 |
| E2 - 实时风控系统架构 | Agent 的调查结果可以作为实时风控决策的输入,或触发异步深度调查流程 |
| E4 - CEP 复杂事件处理 | CEP 检测到的复杂事件模式可以作为 Agent 的触发源(如"盗刷序列检测到 → 启动调查 Agent") |
| B3 - 分布式锁 | Agent 并发调查同一用户时,需要分布式锁防止竞态条件 |
| C5 - Redis 缓存策略 | Agent 的工具调用结果缓存、共享黑板状态存储 |
记忆口诀:
- Agent = 资深分析师的数字分身:有脑子(LLM)、会计划(Planning)、有记忆(Memory)、会用系统(Tool Use)、会复盘(Reflection)
- ReAct = 侦探办案的套路:先想(Thought)→ 再查(Action)→ 看结果(Observation)→ 再想下一步 → 直到破案
- Function Calling = 分析师的系统账号密码:分析师不会自己算,但他知道该登哪个系统、查哪个模块、填什么条件
- Multi-Agent = 专案组协作:总调度(组长)分工 → 各专家(交易/用户/图谱)并行调查 → 汇总报告 → 冲突时组长拍板