面试题集锦:Agent 系统设计

面试题集锦:Agent 系统设计

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:

  1. 信息分散:一笔可疑交易涉及交易数据、用户画像、设备信息、IP 地理位置、关联账户、历史行为——信息散落在 6+ 个系统中
  2. 研判非结构化:不同分析师的研判逻辑不同,没有标准 SOP;资深分析师的"直觉"难以编码为规则
  3. 时效压力:重大风险事件(如盗号批量出金)需要在分钟级内完成调查并处置
  4. 知识沉淀难:分析师的实战经验流失严重,新人培养周期长(6-12 个月)

Agent 的价值在于:将专家的经验固化为可复用的自主工作流。


2. 核心原理与图解

2.1 ReAct 模式:推理与行动的闭环

ReAct(Reasoning + Acting)是 Agent 最经典的执行范式,由 Google 在 2022 年提出。核心思想是:LLM 不应该直接给答案,而是应该像人类一样"先思考、再行动、观察结果、再思考"。

interview agent system design · 图 1
interview agent system design · 图 1 · 点击查看 SVG 原图

ReAct 循环的四个角色:

角色作用示例
Thought(思考)分析当前状况,制定下一步计划"我需要查交易记录"
Action(行动)调用工具,获取外部信息tradeQueryTool(userId=A)
Observation(观察)工具返回的结果"5 笔 9990 USDT 转出"
Final Answer(结论)循环终止时给出的最终答案"疑似 Structuring,建议冻结"

为什么 ReAct 比直接 Prompt 有效?

  1. 分解复杂任务:将"调查可疑交易"分解为可执行的子步骤,降低每一步的认知负荷
  2. 利用外部工具扩展能力:LLM 本身不知道实时交易数据,但可以通过工具查询
  3. 可追溯的推理链:每一步 Thought 都记录在案,便于审计和调试
  4. 错误恢复能力:如果某步工具调用失败,可以在下一步 Thought 中调整策略

2.2 Function Calling:Agent 的"手"

Function Calling(工具调用)是 LLM 与外部世界交互的桥梁。现代 LLM(GPT-4、Claude、Gemini)原生支持根据用户意图自动选择并调用预定义的函数。

interview agent system design · 图 2
interview agent system design · 图 2 · 点击查看 SVG 原图

Function Calling 的三要素:

  1. 工具定义(Schema):用 JSON Schema 描述每个工具的"名字、用途、参数类型、必填项"
  2. 工具注册(Registry):Agent 启动时将工具定义注册到 LLM 的上下文
  3. 工具执行(Execution):LLM 输出 function_call 指令后,Agent 负责解析参数、调用实际函数、返回结果

2.3 记忆体系:Agent 的"笔记"

Agent 的记忆分为三层,解决不同时间尺度的信息存储问题:

interview agent system design · 图 3
interview agent system design · 图 3 · 点击查看 SVG 原图
记忆类型存储内容技术实现生命周期
Short-TermReAct 循环中的完整对话历史LLM 上下文窗口单次对话
Working当前任务的中间状态(TODO 列表、已确认事实)结构化对象(Java Class)单次调查
Long-Term历史案例、处置经验、规则知识向量数据库 + 知识图谱持久化

向量检索流程:

  1. 当前调查进展被 Embedding 为向量
  2. 在向量数据库中检索相似度最高的历史案例(如"Structuring 洗钱模式调查")
  3. 将历史案例的处置经验注入当前上下文,作为 Few-Shot 示例

2.4 反思机制:Agent 的"复盘"

反思(Reflection / Self-Correction)是 Agent 从错误中学习的关键能力。

interview agent system design · 图 4
interview agent system design · 图 4 · 点击查看 SVG 原图

两种反思策略:

  1. 内省反思(Internal Reflection):Agent 自己检查推理链,问自己:

    • "我的结论是否过度推断?"
    • "是否有其他解释可以说明这些证据?"
    • "我是否忽略了某些反例?"
  2. 外部反思(External Reflection):引入更高层 Agent(如"督察 Agent")审查初级 Agent 的结论,或引入人类反馈(RLHF)。

2.5 多 Agent 协作架构

复杂风控调查通常需要多个专业 Agent 协作:

interview agent system design · 图 5
interview agent system design · 图 5 · 点击查看 SVG 原图

多 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:每个调查会话的上下文、历史查询、已确认事实

典型工作流:

  1. 分析师输入:"调查用户 john@contoso.com 的可疑活动"
  2. Copilot 自动执行:
    • 查询 Entra ID:最近登录地点、设备、MFA 状态
    • 查询 Sentinel:该用户触发的所有告警
    • 查询 Defender:该设备的进程、网络连接
    • 威胁情报:关联 IP 是否在已知 C2 列表
  3. 输出:结构化报告 + 攻击链时间线 + 建议的遏制措施

技术亮点:

  • 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 不是互斥的,而是互补的:

维度RAGAgent
核心能力从知识库检索相关信息,增强 LLM 回答自主规划、调用工具、多步推理
适用场景"查知识"(如"什么是 Structuring 洗钱?")"做任务"(如"调查这笔可疑交易")
交互方式单轮或少量轮次,被动响应多轮主动探索,可自主决定下一步
工具调用通常只有"检索"一个工具可调用多种工具(查询、计算、写入)

关系:Agent 内部通常包含 RAG(作为其中一个 Tool)。例如调查 Agent 在分析过程中,可能需要 RAG 检索" Structuring 洗钱的典型模式"作为参考知识。

选型建议:

  • 如果任务有明确的步骤和确定性流程 → 用传统程序
  • 如果任务需要查知识但不需要行动 → 用 RAG
  • 如果任务需要探索、推理、调用多个系统 → 用 Agent

Q2:ReAct 模式为什么比直接给 LLM 所有数据更有效?

答:三个核心原因:

  1. 信息过载:直接给所有数据,LLM 的上下文窗口会被噪声淹没(如 1 万条交易记录),注意力分散。ReAct 让 LLM 按需索取数据,保持上下文精简
  2. 推理可追溯:ReAct 的每一步 Thought 都记录在案,形成"思维链"(Chain of Thought)。如果最终结论错误,可以定位是哪一步推理出了问题
  3. 工具扩展性: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 之间怎么通信?共享什么状态?

答:常见的三种通信模式:

  1. 共享黑板(Shared Blackboard):

    • 所有 Agent 读写同一块共享内存(如 Redis / 数据库)
    • 优点:解耦,Agent 不需要知道其他 Agent 的存在
    • 缺点:并发写入可能导致状态冲突
    • 风控场景适用:调查进展白板(各 Agent 把发现写入,总调度读取)
  2. 消息传递(Message Passing):

    • Agent 之间通过消息队列(Kafka / RabbitMQ)显式通信
    • 优点:异步、可追踪、支持背压
    • 缺点:延迟较高,需要设计消息格式
    • 风控场景适用:跨团队 Agent 协作(如风控 Agent → 合规 Agent)
  3. 直接调用(Direct Invocation):

    • Orchestrator 直接调用 Worker Agent 的方法(如 Java 方法调用)
    • 优点:低延迟、强类型
    • 缺点:耦合度高
    • 风控场景适用:同一 JVM 内的 Agent 协作

共享状态设计:

  • 最小共享:只共享"已确认的事实"(Facts),不共享原始推理过程
  • 版本控制:共享状态带版本号,防止覆盖
  • 权限隔离:Worker Agent 只能写入自己负责的区域,Orchestrator 有权读取全部

Q5:Agent 的"幻觉"问题在风控场景下怎么解决?

答:风控对准确性要求极高,需要多层防护:

  1. 事实 grounding:Agent 的每个结论必须绑定到原始数据(如"风险等级 HIGH,依据:交易记录 #TX12345,黑名单命中地址 0xabc")
  2. 证据链校验:下游系统解析 Agent 的输出时,验证引用的证据是否真实存在
  3. 置信度阈值:置信度 < 0.8 的结论标记为"待人工复核",不自动执行
  4. 对抗测试:定期用已知答案的 case 测试 Agent,检测幻觉率
  5. 人类在环(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 的主要运营成本,需要多层控制:

  1. 上下文压缩:

    • 工具返回的原始数据在注入 Prompt 前做摘要(如 1000 条交易 → "20 笔,累计 99,800 USDT")
    • 使用 LLM 做"上下文总结":每 5 轮对话后,将历史 Thought/Observation 压缩为 1 段摘要
  2. 模型分层:

    • 简单任务(文本分类、摘要)→ GPT-3.5 / Claude Haiku(便宜 10x)
    • 复杂推理(调查分析)→ GPT-4 / Claude Opus(只在关键节点调用)
  3. Token 预算:

    • 单次调查 Token 上限:Input 30K + Output 5K
    • 超过预算则触发"精简模式"(只保留核心证据,丢弃细节)
  4. 缓存机制:

    • 相同查询的结果缓存(如"查用户 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 EngineeringAgent 的 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 = 专案组协作:总调度(组长)分工 → 各专家(交易/用户/图谱)并行调查 → 汇总报告 → 冲突时组长拍板