如何用LangChain实现一个简单的问答机器人Agent

// 展示组件协作关系的简单例子
ConversationChain chain =newConversationChain.Builder()
.setLlm(openAILLM)// LLM作为推理引擎
.setMemory(conversationBufferMemory)// Memory维护对话状态
.setPrompt(customPromptTemplate)// Prompt控制输出格式
.build();

String response = chain.predict("用户输入");

@Tool(name ="product_search", description ="搜索商品信息，输入商品关键词")
publicStringsearchProduct(String keyword){
// 实际的商品搜索逻辑
return productService.search(keyword);
}

// 基础问答机器人的核心代码
publicclassSimpleQABot{
    privateConversationChain chain;

    publicvoidinitialize(){
        OpenAI llm =OpenAI.builder()
        .apiKey(System.getenv("OPENAI_API_KEY"))
        .temperature(0.7)
        .build();

        ConversationBufferMemory memory =newConversationBufferMemory();

        PromptTemplate promptTemplate =PromptTemplate.builder()
        .template("你是一个专业的客服助手，请友好耐心地回答用户问题。\n"+
                  "历史对话：{history}\n"+
                  "用户问题：{input}\n"+
                  "回答：")
        .inputVariables(Arrays.asList("history","input"))
        .build();

        this.chain =ConversationChain.builder()
        .llm(llm)
        .memory(memory)
        .prompt(promptTemplate)
        .build();
    }

    publicStringchat(String userInput){
        return chain.predict(userInput);
    }
}

publicclassSmartAgent{
    privateAgentExecutor agent;
    privateOpenAI llm;

    publicvoidsetupAgent(){
        this.llm =OpenAI.builder()
        .apiKey(System.getenv("OPENAI_API_KEY"))
        .temperature(0.3)
        .build();

        // 定义工具集
        List<Tool> tools =Arrays.asList(
            createSearchTool(),
            createCalculatorTool(),
            createDatabaseTool()
        );

        // 初始化Agent
        this.agent =AgentExecutor.fromAgentAndTools()
        .agent(ZeroShotReactDescription.create(llm, tools))
        .tools(tools)
        .maxIterations(3)// 防止无限循环
        .verbose(true)// 开发阶段可以看到推理过程
        .build();
    }

    privateToolcreateSearchTool(){
        returnTool.builder()
        .name("search")
        .description("搜索商品信息，输入商品关键词，返回商品列表")
        .func(keyword ->{
            // 实际调用商品搜索服务
            List<Product> products = productService.search(keyword);
            return products.stream()
            .map(p -> p.getName()+":"+ p.getPrice())
            .collect(Collectors.joining("\n"));
        })
        .build();
    }

    privateToolcreateCalculatorTool(){
        returnTool.builder()
        .name("calculator")
        .description("执行数学计算，输入数学表达式")
        .func(expression ->{
            try{
                returnString.valueOf(evaluateExpression(expression));
            }catch(Exception e){
                return"计算错误："+ e.getMessage();
            }
        })
        .build();
    }
}

publicStringsafeChat(String userInput){
    try{
        // 添加超时控制
        CompletableFuture<String> future =CompletableFuture.supplyAsync(()->
                                                                        chain.predict(userInput)
                                                                       );

        return future.get(30,TimeUnit.SECONDS);

    }catch(TimeoutException e){
        logger.warn("LLM调用超时: {}", userInput);
        return"系统繁忙，请稍后重试";

    }catch(Exception e){
        logger.error("LLM调用异常: {}", e.getMessage());
        // 降级到模板回复
        returnfallbackResponse(userInput);
    }
}

privateStringfallbackResponse(String input){
    // 基于关键词匹配的简单回复逻辑
    if(input.contains("订单")){
        return"请提供您的订单号，我来帮您查询";
    }elseif(input.contains("退款")){
        return"退款相关问题请联系人工客服：400-xxx-xxxx";
    }
    return"抱歉，我没理解您的问题，请您重新描述一下";
}

@Component
publicclassLLMService{
    privatefinalLoadingCache<String,String> responseCache;
    privatefinalSemaphore rateLimiter;

    publicLLMService(){
        this.responseCache =Caffeine.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(1,TimeUnit.HOURS)
        .build(this::callLLMDirectly);

        this.rateLimiter =newSemaphore(10);// 最大10个并发请求
    }

    publicStringcallLLM(String input)throwsException{
        // 先尝试获取许可
        if(!rateLimiter.tryAcquire(5,TimeUnit.SECONDS)){
            thrownewRuntimeException("系统繁忙，请稍后重试");
        }

        try{
            return responseCache.get(input);
        }finally{
            rateLimiter.release();
        }
    }
}