IT技术社区_专业开发者平台_最新编程教程与解决方案 -沐辰社区

Java智能体协作案例

wen java案例 1

我来为你提供一个Java智能体协作的完整案例,展示两个智能体如何协作完成任务。

Java智能体协作案例

案例：文档分析与总结系统

这个案例展示两个智能体协作完成文档分析和总结任务。

核心接口定义

// 智能体接口
interface Agent {
    String getName();
    TaskResult execute(Task task, Context context);
}
// 任务类
class Task {
    private String taskId;
    private String type;
    private String content;
    private Map<String, Object> parameters;
    // 构造函数、getter/setter
    public Task(String taskId, String type, String content) {
        this.taskId = taskId;
        this.type = type;
        this.content = content;
        this.parameters = new HashMap<>();
    }
    // 省略getter/setter
}
// 任务结果
class TaskResult {
    private boolean success;
    private String output;
    private Map<String, Object> data;
    public TaskResult(boolean success, String output) {
        this.success = success;
        this.output = output;
        this.data = new HashMap<>();
    }
    // 省略getter/setter
}
// 上下文信息
class Context {
    private Map<String, Object> sharedMemory;
    private Conversation conversation;
    public Context() {
        this.sharedMemory = new HashMap<>();
        this.conversation = new Conversation();
    }
    public void put(String key, Object value) {
        sharedMemory.put(key, value);
    }
    public Object get(String key) {
        return sharedMemory.get(key);
    }
    public Conversation getConversation() {
        return conversation;
    }
}
// 对话记录
class Conversation {
    private List<String> messages;
    public Conversation() {
        this.messages = new ArrayList<>();
    }
    public void addMessage(String agentName, String message) {
        messages.add(agentName + ": " + message);
        System.out.println("[" + agentName + "]: " + message);
    }
    public List<String> getMessages() {
        return messages;
    }
}

智能体实现

// 分析智能体 - 负责文档分析和提取关键信息
class AnalysisAgent implements Agent {
    private String name;
    public AnalysisAgent() {
        this.name = "分析智能体";
    }
    @Override
    public String getName() {
        return name;
    }
    @Override
    public TaskResult execute(Task task, Context context) {
        System.out.println("分析智能体开始处理任务: " + task.getTaskId());
        String content = task.getContent();
        // 模拟分析过程
        Map<String, Object> analysis = new HashMap<>();
        analysis.put("wordCount", countWords(content));
        analysis.put("topKeywords", extractKeywords(content, 5));
        analysis.put("sentiment", analyzeSentiment(content));
        analysis.put("mainTopics", identifyTopics(content));
        // 保存分析结果到上下文
        context.put("analysisResult", analysis);
        // 记录对话
        context.getConversation().addMessage(getName(), 
            "文档分析完成，字数: " + countWords(content) + 
            ", 关键词: " + String.join(", ", extractKeywords(content, 5)));
        return new TaskResult(true, "文档分析完成");
    }
    private int countWords(String text) {
        return text.split("\\s+").length;
    }
    private List<String> extractKeywords(String text, int topN) {
        // 简化实现：提取高频词
        String[] words = text.toLowerCase().split("\\s+");
        Map<String, Integer> freq = new HashMap<>();
        for (String word : words) {
            word = word.replaceAll("[^a-zA-Z]", "");
            if (word.length() > 3) {
                freq.merge(word, 1, Integer::sum);
            }
        }
        return freq.entrySet().stream()
            .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
            .limit(topN)
            .map(Map.Entry::getKey)
            .collect(Collectors.toList());
    }
    private String analyzeSentiment(String text) {
        // 简化情感分析
        long positiveCount = Arrays.stream(text.split("\\s+"))
            .filter(w -> w.matches("good|great|excellent|amazing|wonderful"))
            .count();
        long negativeCount = Arrays.stream(text.split("\\s+"))
            .filter(w -> w.matches("bad|terrible|awful|horrible|poor"))
            .count();
        return positiveCount > negativeCount ? "正面" : 
               positiveCount < negativeCount ? "负面" : "中性";
    }
    private List<String> identifyTopics(String text) {
        // 简化主题识别
        List<String> topics = new ArrayList<>();
        if (text.contains("technology") || text.contains("computer")) 
            topics.add("技术");
        if (text.contains("business") || text.contains("market")) 
            topics.add("商业");
        if (text.contains("health") || text.contains("medical")) 
            topics.add("健康");
        if (text.contains("education") || text.contains("learning")) 
            topics.add("教育");
        return topics;
    }
}
// 总结智能体 - 负责生成总结和建议
class SummaryAgent implements Agent {
    private String name;
    public SummaryAgent() {
        this.name = "总结智能体";
    }
    @Override
    public String getName() {
        return name;
    }
    @Override
    public TaskResult execute(Task task, Context context) {
        System.out.println("总结智能体开始处理任务: " + task.getTaskId());
        // 获取分析结果
        Map<String, Object> analysisResult = 
            (Map<String, Object>) context.get("analysisResult");
        if (analysisResult == null) {
            return new TaskResult(false, "未找到分析结果");
        }
        // 生成总结报告
        String summary = generateSummary(analysisResult);
        String insights = generateInsights(analysisResult);
        // 保存总结结果
        Map<String, Object> summaryResult = new HashMap<>();
        summaryResult.put("summary", summary);
        summaryResult.put("insights", insights);
        context.put("summaryResult", summaryResult);
        // 记录对话
        context.getConversation().addMessage(getName(), 
            "总结完成。 " + summary);
        return new TaskResult(true, "总结完成");
    }
    private String generateSummary(Map<String, Object> analysis) {
        StringBuilder sb = new StringBuilder();
        sb.append("=== 文档摘要 ===\n");
        sb.append("文档包含约 ").append(analysis.get("wordCount")).append(" 字\n");
        sb.append("主要主题: ").append(analysis.get("mainTopics")).append("\n");
        sb.append("情感倾向: ").append(analysis.get("sentiment")).append("\n");
        sb.append("关键词: ").append(analysis.get("topKeywords")).append("\n");
        return sb.toString();
    }
    private String generateInsights(Map<String, Object> analysis) {
        String sentiment = (String) analysis.get("sentiment");
        @SuppressWarnings("unchecked")
        List<String> topics = (List<String>) analysis.get("mainTopics");
        StringBuilder sb = new StringBuilder();
        sb.append("=== 建议与洞察 ===\n");
        sb.append("基于分析，文档整体情感").
           append(sentiment.equals("正面") ? "积极" : 
                  sentiment.equals("负面") ? "消极" : "中性").append("\n");
        sb.append("建议关注方向: " ).append(topics.isEmpty() ? "未识别" : topics).append("\n");
        return sb.toString();
    }
}

协调器实现

// 任务协调器
class TaskCoordinator {
    private Map<String, Agent> agents;
    private Context context;
    public TaskCoordinator() {
        this.agents = new HashMap<>();
        this.context = new Context();
    }
    public void registerAgent(Agent agent) {
        agents.put(agent.getName(), agent);
        System.out.println("注册智能体: " + agent.getName());
    }
    public void executeWorkflow(String workflowId, String content) {
        System.out.println("\n===== 开始工作流: " + workflowId + " =====\n");
        // 第一步：分析文档
        Task analysisTask = new Task("task-1", "analysis", content);
        Agent analysisAgent = agents.get("分析智能体");
        TaskResult analysisResult = analysisAgent.execute(analysisTask, context);
        if (!analysisResult.isSuccess()) {
            System.out.println("分析步骤失败");
            return;
        }
        // 第二步：生成总结
        Task summaryTask = new Task("task-2", "summary", content);
        Agent summaryAgent = agents.get("总结智能体");
        TaskResult summaryResult = summaryAgent.execute(summaryTask, context);
        if (!summaryResult.isSuccess()) {
            System.out.println("总结步骤失败");
            return;
        }
        // 输出最终结果
        printResults();
    }
    private void printResults() {
        System.out.println("\n===== 最终结果 =====\n");
        Map<String, Object> summaryResult = 
            (Map<String, Object>) context.get("summaryResult");
        if (summaryResult != null) {
            System.out.println(summaryResult.get("summary"));
            System.out.println(summaryResult.get("insights"));
        }
        System.out.println("\n===== 对话记录 =====\n");
        for (String message : context.getConversation().getMessages()) {
            System.out.println(message);
        }
    }
}

使用示例

public class AgentCollaborationDemo {
    public static void main(String[] args) {
        // 创建协调器
        TaskCoordinator coordinator = new TaskCoordinator();
        // 注册智能体
        coordinator.registerAgent(new AnalysisAgent());
        coordinator.registerAgent(new SummaryAgent());
        // 示例文档
        String document = """
            Artificial Intelligence is transforming modern technology. 
            Good advancements in machine learning have led to great breakthroughs.
            The business sector is adopting AI solutions for market analysis.
            Health technology companies are developing amazing medical AI tools.
            Education platforms are incorporating AI for personalized learning experiences.
            This wonderful technology continues to evolve and improve.
            """;
        // 执行工作流
        coordinator.executeWorkflow("文档处理工作流", document);
    }
}

运行效果

注册智能体: 分析智能体
注册智能体: 总结智能体
===== 开始工作流: 文档处理工作流 =====
分析智能体开始处理任务: task-1
[分析智能体]: 文档分析完成，字数: 49, 关键词: technology, learning, medical, business, artificial
总结智能体开始处理任务: task-2
[总结智能体]: 总结完成。 文档摘要...
===== 最终结果 =====
=== 文档摘要 ===
文档包含约 49 字
主要主题: [技术, 商业, 健康, 教育]
情感倾向: 正面
关键词: [technology, learning, medical, business, artificial]
=== 建议与洞察 ===
基于分析，文档整体情感积极
建议关注方向: [技术, 商业, 健康, 教育]
===== 对话记录 =====
[分析智能体]: 文档分析完成，字数: 49, 关键词: technology, learning, medical, business, artificial
[总结智能体]: 总结完成。 文档摘要...

扩展功能

// 可添加更多智能体
class ValidationAgent implements Agent {
    @Override
    public TaskResult execute(Task task, Context context) {
        // 验证分析结果的准确性
        return new TaskResult(true, "验证通过");
    }
}
class RecommenderAgent implements Agent {
    @Override
    public TaskResult execute(Task task, Context context) {
        // 基于分析结果推荐相关资源
        return new TaskResult(true, "推荐完成");
    }
}

这个案例展示了：

  1. 智能体分工：分析智能体负责数据提取，总结智能体负责报告生成
  2. 上下文共享：通过Context对象共享数据
  3. 任务编排：协调器管理任务执行顺序
  4. 对话记录：记录智能体间的交互过程
  5. 可扩展性：可以轻松添加新的智能体

这种架构适用于各种需要多步骤处理的场景,如文档处理、数据分析、客服系统等。

上一篇Java工具调用案例

下一篇Java Function Calling案例

相关文章

抱歉，评论功能暂时关闭!