AgentScope Java实战博客：从入门到落地，解锁智能代理开发新范式

<!-- AgentScope Java核心依赖 -->
<dependency>
    <groupId>com.agentscope</groupId>
    <artifactId>agentscope-java-sdk</artifactId>
    <version>1.0.0</version>
</dependency>

<!-- 可选：如果使用OpenAI大模型，添加此依赖 -->
<dependency>
    <groupId>com.agentscope</groupId>
    <artifactId>agentscope-model-openai</artifactId>
    <version>1.0.0</version>
</dependency>

<!-- 可选：如果使用通义千问大模型，添加此依赖 -->
<dependency>
    <groupId>com.agentscope</groupId>
    <artifactId>agentscope-model-qwen</artifactId>
    <version>1.0.0</version>
</dependency>

agentscope:
  # 大模型配置（以OpenAI为例）
  model:
    type: openai  # 模型类型：openai、qwen、ernie等
    api-key: sk-xxxxxxxxxxxxxxxxxxxxxx  # 你的大模型API密钥
    base-url: https://api.openai.com/v1  # 大模型API地址（OpenAI默认，国内需配置代理）
    model-name: gpt-3.5-turbo  # 模型名称，可根据需求调整（如gpt-4）
  # 日志配置（可选，贴合Java日志习惯）
  log:
    level: info  # 日志级别：debug、info、warn、error
    path: ./logs/agentscope  # 日志存储路径

import com.agentscope.Agent;
import com.agentscope.model.openai.OpenAIModel;
import com.agentscope.request.ChatRequest;
import com.agentscope.response.ChatResponse;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component  // Spring Boot组件，可通过依赖注入使用
public class CodeGenerateAgent {

    // 从配置文件中读取API密钥和模型名称
    @Value("${agentscope.model.api-key}")
    private String apiKey;

    @Value("${agentscope.model.model-name}")
    private String modelName;

    // 创建Agent并调用大模型
    public String generateUserEntity() {
        // 1. 初始化大模型（OpenAI）
        OpenAIModel openAIModel = new OpenAIModel(apiKey, modelName);

        // 2. 创建Agent，指定Agent名称和绑定的大模型
        Agent codeAgent = Agent.builder()
                .name("CodeGenerateAgent")  // Agent名称，便于区分
                .model(openAIModel)         // 绑定大模型
                .build();

        // 3. 构建请求：明确指令，让Agent生成Java实体类
        ChatRequest request = ChatRequest.builder()
                .prompt("生成一个Java User实体类，包含id（Long）、username（String）、password（String）、createTime（LocalDateTime）字段，生成getter/setter方法和toString方法，遵循Java开发规范。")
                .build();

        // 4. 调用Agent，获取响应
        ChatResponse response = codeAgent.chat(request);

        // 5. 返回大模型生成的结果
        return response.getContent();
    }

    // 测试方法（可在main方法或单元测试中运行）
    public static void main(String[] args) {
        CodeGenerateAgent agent = new CodeGenerateAgent();
        // 手动赋值（非Spring环境下，可直接赋值API密钥）
        agent.apiKey = "sk-xxxxxxxxxxxxxxxxxxxxxx";
        agent.modelName = "gpt-3.5-turbo";
        String result = agent.generateUserEntity();
        System.out.println("生成的Java实体类：\n" + result);
    }
}

import com.agentscope.Agent;
import com.agentscope.model.openai.OpenAIModel;
import com.agentscope.request.ChatRequest;
import com.agentscope.response.ChatResponse;

public class MultiAgentDemo {

    public static void main(String[] args) {
        // 1. 初始化大模型（共用一个OpenAI模型，也可分别使用不同模型）
        String apiKey = "sk-xxxxxxxxxxxxxxxxxxxxxx";
        String modelName = "gpt-3.5-turbo";
        OpenAIModel openAIModel = new OpenAIModel(apiKey, modelName);

        // 2. 创建咨询Agent：负责识别用户问题类型
        Agent consultAgent = Agent.builder()
                .name("ConsultAgent")
                .model(openAIModel)
                .promptTemplate("用户问题：{userQuestion}\n请识别该问题的类型，只能返回「订单咨询」「账户咨询」「其他」，无需额外解释。")
                .build();

        // 3. 创建知识库Agent：负责根据问题类型给出答案
        Agent knowledgeAgent = Agent.builder()
                .name("KnowledgeAgent")
                .model(openAIModel)
                .promptTemplate("问题类型：{questionType}\n用户问题：{userQuestion}\n请根据问题类型，给出简洁、专业的回答，符合Java企业级应用的业务逻辑。")
                .build();

        // 4. 模拟用户问题
        String userQuestion = "我的账户登录失败，提示密码错误，该怎么解决？";

        // 5. 多Agent协同：先调用咨询Agent识别问题类型，再调用知识库Agent给出答案
        // 5.1 咨询Agent识别问题类型
        ChatRequest consultRequest = ChatRequest.builder()
                .param("userQuestion", userQuestion)  // 替换promptTemplate中的占位符
                .build();
        ChatResponse consultResponse = consultAgent.chat(consultRequest);
        String questionType = consultResponse.getContent();  // 输出：账户咨询

        // 5.2 知识库Agent给出答案
        ChatRequest knowledgeRequest = ChatRequest.builder()
                .param("questionType", questionType)
                .param("userQuestion", userQuestion)
                .build();
        ChatResponse knowledgeResponse = knowledgeAgent.chat(knowledgeRequest);

        // 6. 输出最终结果
        System.out.println("用户问题：" + userQuestion);
        System.out.println("问题类型：" + questionType);
        System.out.println("回答：" + knowledgeResponse.getContent());
    }
}

// 1. 配置类：初始化Agent和大模型（通过配置文件注入）
import com.agentscope.Agent;
import com.agentscope.model.openai.OpenAIModel;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AgentScopeConfig {

    @Value("${agentscope.model.api-key}")
    private String apiKey;

    @Value("${agentscope.model.model-name}")
    private String modelName;

    // 初始化大模型
    @Bean
    public OpenAIModel openAIModel() {
        return new OpenAIModel(apiKey, modelName);
    }

    // 初始化代码生成Agent，交给Spring管理
    @Bean
    public Agent codeGenerateAgent(OpenAIModel openAIModel) {
        return Agent.builder()
                .name("CodeGenerateAgent")
                .model(openAIModel)
                .promptTemplate("生成Java代码：{code需求}\n要求：语法正确、符合Java开发规范、注释清晰，无需额外解释。")
                .build();
    }
}

// 2. 控制层：提供接口，接收前端请求
import com.agentscope.Agent;
import com.agentscope.request.ChatRequest;
import com.agentscope.response.ChatResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/agent")
public class AgentController {

    @Autowired
    private Agent codeGenerateAgent;

    // 接收前端传递的代码需求，调用Agent生成代码
    @PostMapping("/generate/code")
    public String generateCode(@RequestBody CodeRequest request) {
        ChatRequest chatRequest = ChatRequest.builder()
                .param("code需求", request.getCodeDemand())
                .build();
        ChatResponse chatResponse = codeGenerateAgent.chat(chatRequest);
        return chatResponse.getContent();
    }

    // 接收参数的实体类
    static class CodeRequest {
        private String codeDemand;

        // getter/setter方法
        public String getCodeDemand() {
            return codeDemand;
        }

        public void setCodeDemand(String codeDemand) {
            this.codeDemand = codeDemand;
        }
    }
}

// 初始化上下文，保存对话历史
Context context = new Context();

// 第一次请求：添加对话历史到上下文
ChatRequest request1 = ChatRequest.builder()
        .prompt("生成一个Java User实体类")
        .build();
ChatResponse response1 = codeAgent.chat(request1, context);

// 第二次请求：上下文会自动携带上一轮对话，无需重复提示
ChatRequest request2 = ChatRequest.builder()
        .prompt("给这个实体类添加一个age字段（Integer类型）")
        .build();
ChatResponse response2 = codeAgent.chat(request2, context);

// 上下文可手动清理、添加、修改
context.clear();  // 清理对话历史
context.addMessage("用户", "重新生成一个Admin实体类");  // 手动添加对话

try {
    ChatResponse response = codeAgent.chat(request);
    return response.getContent();
} catch (ModelException e) {
    // 大模型调用异常（如API密钥错误、模型不存在）
    log.error("大模型调用失败：{}", e.getMessage(), e);
    return "大模型调用失败，请检查API密钥和模型配置";
} catch (AgentException e) {
    // Agent相关异常（如Agent未初始化、上下文异常）
    log.error("Agent调用异常：{}", e.getMessage(), e);
    return "系统异常，请稍后重试";
} catch (Exception e) {
    // 通用异常
    log.error("未知异常：{}", e.getMessage(), e);
    return "系统繁忙，请稍后重试";
}

# 切换为通义千问模型
agentscope:
  model:
    type: qwen
    api-key: sk-xxxxxxxxxxxxxxxxxxxxxx
    base-url: https://dashscope.aliyuncs.com/api/v1
    model-name: qwen-turbo

// 无需指定模型类型，Spring根据配置自动注入
@Autowired
private Agent codeGenerateAgent;