LangChain4j实战之十三：函数调用，低级API版本

程序员欣宸2026-01-14 21:02

欢迎访问我的GitHub

这里分类和汇总了欣宸的全部原创(含配套源码)：https://github.com/zq2599/blog_demos

LangChain4j实战全系列链接

  1. 准备工作
  2. 极速开发体验
  3. 细说聊天API
  4. 集成到spring-boot
  5. 图像模型
  6. 聊天记忆，低级API版
  7. 聊天记忆，高级API版
  8. 响应流式传输
  9. 高级API(AI Services)实例的创建方式
  10. 结构化输出之一，用提示词指定输出格式
  11. 结构化输出之二，function call
  12. 结构化输出之三，json模式
  13. 函数调用，低级API版本

关于函数调用

  • 随着学习的深入，咱们逐渐开始接触到各类重要能力了，函数调用就是其中的一个
  • 可以按照以下六步来理解函数调用到底是什么：
  1. 开发者写一个本地方法A
  2. 第一次和LLM对话，把提示词和方法A的签名都给到LLM
  3. LLM返回信息中，会说明用什么参数去调用A
  4. 按照LLM返回的参数去调用A
  5. 把调用A的返回值返回给LLM
  6. LLM根据这个返回值来生成最终的结果，并返回给用户

  • 如果是低级API方案，步骤2到5由开发者自己写代码实现，如果是高级API方案，步骤2到5由LangChain4j代为执行

  • 注意重点：用户最终拿到的不是本地方法的结果，而是LLM根据本地方法的结果生成的内容

  • 完整时序图如下

本地天气工具 大模型 LangChain4j 客户端代码 用户 本地天气工具 大模型 LangChain4j 客户端代码 用户 "查一下深圳的天气" 构建请求 携带 toolSpecifications(天气工具) 1️⃣ 请求1 messages=[UserMessage("查一下深圳的天气")] tools=[天气工具Schema] 判断需要调用天气工具 返回 tool_call {"name":"getWeather","arguments":{"city":"深圳"}} 反射调用 getWeather("深圳") 返回结果 {"temp":28,"unit":"°C","desc":"多云"} 2️⃣ 请求2 messages=[ UserMessage("查一下深圳的天气"), ToolExecutionRequest(...), ToolExecutionResult({"temp":28...}) ] 结合工具结果生成自然语言回答 返回 AssistantMessage "深圳当前气温28°C，多云" 封装为 String/对象 "深圳当前气温28°C，多云"

  • 其实在《结构化输出之二，function call》一文咱们已经体验过函数调用了，不过那时的重点是让LLM按照函数定义把返回内容转为JSON，至于函数的结果并不关心，以至于本地方法直接返回null了
  • 而今天咱们要学的是让本地方法实实在在的执行，返回有效的结果给LLM，再看用户真正收到的响应和这个本地方法的结果有啥区别

本篇概览

  • 本篇要实战的是低级API版本，也就是说两次LLM对话还有每次LLM响应的处理，都是咱们自己编码实现的，如下图红框中的部分

  • 比起高级API版本确实要多做很多事情，优点是全流程自己掌控，适合需要深度定制的场景

  • 本次实战有关的业务，就选天气预报吧，这种实时数据LLM是没有的，所以用自定义函数获取实时天气数据，再走函数调用的方式返回给用户，是个不错的例子

  • 为了观察和LLM通信的详情，咱们还会把每次和LLM交互的详细数据打印出来用

准备工作：如何获取实时天气数据

  • 有多种方式可以从公网查询到天气信息，我这里选择了接口盒子网站提供的http服务，网站情况如下图
  • 接口盒子网站提供的天气服务是免费的，但是需要您自己去注册一个账号，得到属于您自己的开发者ID和开发者KEY
  • 有了上述两个关键信息，咱们就能通过拼接URL来查询某地的天气情况了，收到的返回值是个JSON，为了方便处理，咱们为此JSON准备一个对应的数据结构
  • 好了，该说的都说清楚了，接下来开始编码吧

源码下载（觉得作者啰嗦的，直接在这里下载）

名称 链接 备注
项目主页 https://github.com/zq2599/blog_demos 该项目在GitHub上的主页
git仓库地址(https) https://github.com/zq2599/blog_demos.git 该项目源码的仓库地址，https协议
git仓库地址(ssh) git@github.com:zq2599/blog_demos.git 该项目源码的仓库地址，ssh协议
  • 这个git项目中有多个文件夹，本篇的源码在langchain4j-tutorials文件夹下，如下图红色箭头所示：

编码：父工程调整

  • 《准备工作》中创建了整个《LangChain4j实战》系列代码的父工程，本篇实战会在父工程下新建一个子工程，所以这里要对父工程的pom.xml做少量修改
  1. modules中增加一个子工程，如下图黄框所示

编码：新增子工程

  • 新增名为tools-low-level的子工程
  1. langchain4j-totorials目录下新增名tools-low-level为的文件夹
  2. tools-low-level文件夹下新增pom.xml，内容如下
xml 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.bolingcavalry</groupId>
        <artifactId>langchain4j-totorials</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>tools-low-level</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        
        <!-- Spring Boot Starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        
        <!-- Spring Boot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- Spring Boot Test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!-- JUnit Jupiter Engine -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!-- Mockito Core -->
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!-- Mockito JUnit Jupiter -->
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!-- LangChain4j Core -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-core</artifactId>
        </dependency>
        
        <!-- LangChain4j OpenAI支持（用于通义千问的OpenAI兼容接口） -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai</artifactId>
        </dependency>

        <!-- 官方 langchain4j（包含 AiServices 等服务类） -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j</artifactId>
        </dependency>

        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-community-dashscope</artifactId>
        </dependency>

        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-spring-boot-starter</artifactId>
        </dependency>

        <!-- 日志依赖由Spring Boot Starter自动管理，无需单独声明 -->
    </dependencies>

    <build>
        <plugins>
            <!-- Spring Boot Maven Plugin -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>3.3.5</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>
  1. 在langchain4j-totorials/tools-low-level/src/main/resources新增配置文件application.properties，内容如下，主要是三个模型的配置信息，记得把your-api-key换成您自己的apikey，另外由于用到了接口盒子的服务查询，相关的ulr模板、用户id、用户key也在这里面配置好
properties 复制代码 
# Spring Boot 应用配置
server.port=8080
server.servlet.context-path=/

# LangChain4j 使用OpenAI兼容模式配置通义千问模型
# 注意：请将your-api-key替换为您实际的通义千问API密钥
langchain4j.open-ai.chat-model.api-key=your-api-key
# 通义千问模型名称
langchain4j.open-ai.chat-model.model-name=qwen3-max
# 阿里云百炼OpenAI兼容接口地址
langchain4j.open-ai.chat-model.base-url=https://dashscope.aliyuncs.com/compatible-mode/v1

# 日志配置
logging.level.root=INFO
logging.level.com.bolingcavalry=DEBUG
logging.pattern.console=%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
# 应用名称
spring.application.name=tools-low-level


# 调用接口盒子的接口查询天气，这里是地址
weather.tools.url=https://cn.apihz.cn/api/tianqi/tqyb.php?id=%s&key=%s&sheng=%s&place=%s
# 调用接口盒子的接口查询天气，这里是ID，请改成您自己的注册ID
weather.tools.id=your-id
# 调用接口盒子的接口查询天气，这里是通讯KEY，请改成您自己的通讯KEY
weather.tools.key=your-key
  1. 新增启动类，依旧平平无奇
java 复制代码 
package com.bolingcavalry;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Spring Boot应用程序的主类
 */
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
  • 接口盒子返回的json数据，要准备数据结构来保存，由于有嵌套对象，所以需要两个pojo，第一个是NowInfo，存的是实时数据，如温度湿度
java 复制代码 
package com.bolingcavalry.vo;

import lombok.Data;

import java.io.Serializable;

@Data
public class NowInfo implements Serializable {
    private double precipitation;
    private double temperature;
    private int pressure;
    private int humidity;
    private String windDirection;
    private int windDirectionDegree;
    private int windSpeed;
    private String windScale;
    private double feelst;
    private String uptime;
}
  • 第二个pojo是WeatherInfo，对应的是接口返回的完整JSON
java 复制代码 
package com.bolingcavalry.vo;

import lombok.Data;

import java.io.Serializable;

@Data
public class WeatherInfo implements Serializable {
    private int code;
    private String guo;
    private String sheng;
    private String shi;
    private String name;
    private String weather1;
    private String weather2;
    private int wd1;
    private int wd2;
    private String winddirection1;
    private String winddirection2;
    private String windleve1;
    private String windleve2;
    private String weather1img;
    private String weather2img;
    private double lon;
    private double lat;
    private String uptime;
    private NowInfo nowinfo;
    private Object alarm;
}
  • 然后是本篇的第一个重点：自定义函数，该函数的作用是调用接口盒子的HTTP服务获取实时天气，需要注意的是要用Tool注解修饰
java 复制代码 
package com.bolingcavalry.service;

import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.client.RestTemplate;

import com.bolingcavalry.vo.WeatherInfo;

import dev.langchain4j.agent.tool.P;
import dev.langchain4j.agent.tool.Tool;
import lombok.Data;

@Data
public class WeatherTools {

    private static final Logger logger = LoggerFactory.getLogger(WeatherTools.class);

    private String weatherToolsUrl;
    private String weatherToolsId;
    private String weatherToolsKey;


    @SuppressWarnings("null")
    @Tool("返回给定省份和城市的天气预报综合信息")
    public WeatherInfo getWeather(@P("应返回天气预报的省份") String province, @P("应返回天气预报的城市") String city) throws IllegalArgumentException {
        String encodedProvince = URLEncoder.encode(province, StandardCharsets.UTF_8);
        String encodedCity = URLEncoder.encode(city, StandardCharsets.UTF_8);
        String url = String.format(weatherToolsUrl, weatherToolsId, weatherToolsKey, encodedProvince, encodedCity);
        logger.info("调用天气接口：{}", url);
        return new RestTemplate().getForObject(url, WeatherInfo.class);
    }
}
  • 接着是配置类，里面创建了天气服务类和LLM模型服务类的bean，要注意的是在创建模型服务类的时候设置了监听类ChatModelListener，这样服务和LLM的每一次请求响应详情都会打印到日志
java 复制代码 
package com.bolingcavalry.config;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.bolingcavalry.service.QwenService;
import com.bolingcavalry.service.WeatherTools;

import dev.langchain4j.agent.tool.ToolExecutionRequest;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.model.chat.listener.ChatModelErrorContext;
import dev.langchain4j.model.chat.listener.ChatModelListener;
import dev.langchain4j.model.chat.listener.ChatModelRequestContext;
import dev.langchain4j.model.chat.listener.ChatModelResponseContext;
import dev.langchain4j.model.chat.response.ChatResponse;
import dev.langchain4j.model.openai.OpenAiChatModel;

/**
 * LangChain4j配置类
 */
@Configuration
public class LangChain4jConfig {

    private static final Logger logger = LoggerFactory.getLogger(LangChain4jConfig.class);

    @Value("${langchain4j.open-ai.chat-model.api-key}")
    private String apiKey;

    @Value("${langchain4j.open-ai.chat-model.model-name:qwen-turbo}")
    private String modelName;

    @Value("${langchain4j.open-ai.chat-model.base-url}")
    private String baseUrl;

    /**
     * 创建并配置OpenAiChatModel实例（使用通义千问的OpenAI兼容接口）
     * 
     * @return OpenAiChatModel实例
     */
    @Bean
    public OpenAiChatModel chatModel() {
        ChatModelListener listener = new ChatModelListener() {
            @Override
            public void onRequest(ChatModelRequestContext reqCtx) {
                // 1. 拿到 List<ChatMessage>
                List<ChatMessage> messages = reqCtx.chatRequest().messages();
                logger.info("发到LLM的请求: {}", messages);
                
            }

            @Override
            public void onResponse(ChatModelResponseContext respCtx) {
                // 2. 先取 ChatModelResponse
                ChatResponse response = respCtx.chatResponse();
                // 3. 再取 AiMessage
                AiMessage aiMessage = response.aiMessage();

                // 4. 工具调用
                List<ToolExecutionRequest> tools = aiMessage.toolExecutionRequests();
                for (ToolExecutionRequest t : tools) {
                    logger.info("LLM响应, 执行函数[{}], 函数入参 : {}", t.name(), t.arguments());
                }

                // 5. 纯文本
                if (aiMessage.text() != null) {
                    logger.info("LLM响应, 纯文本 : {}", aiMessage.text());
                }
            }

            @Override
            public void onError(ChatModelErrorContext errorCtx) {
                errorCtx.error().printStackTrace();
            }
        };

        return OpenAiChatModel.builder()
                .apiKey(apiKey)
                .modelName(modelName)
                .baseUrl(baseUrl)
                .listeners(List.of(listener))
                .build();
    }

    @Value("${weather.tools.url}")
    private String weatherToolsUrl;

    @Value("${weather.tools.id}")
    private String weatherToolsId;

    @Value("${weather.tools.key}")
    private String weatherToolsKey;

    @Bean
    public WeatherTools weatherTools() {
        WeatherTools tools = new WeatherTools();
        tools.setWeatherToolsUrl(weatherToolsUrl);
        tools.setWeatherToolsId(weatherToolsId);
        tools.setWeatherToolsKey(weatherToolsKey);
        return tools;
    }
}
  • 接下来，重点来了：我们要自己实现和LLM的两次通信，并且在第一次收到响应时，要根据LLM给定的参数去调用查询天气的服务类，下面先给出完整代码，再详细说明其中的重点
java 复制代码 
package com.bolingcavalry.service;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.bolingcavalry.vo.WeatherInfo;

import dev.langchain4j.agent.tool.ToolExecutionRequest;
import dev.langchain4j.agent.tool.ToolSpecification;
import dev.langchain4j.agent.tool.ToolSpecifications;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.data.message.ToolExecutionResultMessage;
import dev.langchain4j.model.chat.request.ChatRequest;
import dev.langchain4j.model.chat.response.ChatResponse;
import dev.langchain4j.model.openai.OpenAiChatModel;

/**
 * 通义千问服务类，用于与通义千问模型进行交互
 */
@Service
public class QwenService {

    private static final Logger logger = LoggerFactory.getLogger(QwenService.class);

    @Autowired
    private OpenAiChatModel openAiChatModel;

    @Autowired
    private WeatherTools weatherTools;

    private List<ToolSpecification> prepareToolSpecifications() {
        return ToolSpecifications.toolSpecificationsFrom(WeatherTools.class);
    }

    /**
     * 处理工具执行请求
     */
    private String executeTool(ToolExecutionRequest request) {
        try {
            if ("getWeather".equals(request.name())) {
                String arguments = request.arguments();
                logger.info("执行工具调用：getWeather，参数：{}", arguments);

                // 简单解析 JSON 参数
                String province = null;
                String city = null;

                // 检查参数格式
                if (arguments.contains("arg0") && arguments.contains("arg1")) {
                    // 格式：{"arg0": "广东", "arg1": "深圳"}
                    province = extractValue(arguments, "arg0");
                    city = extractValue(arguments, "arg1");
                } else if (arguments.contains("province") && arguments.contains("city")) {
                    // 格式：{"province": "广东", "city": "深圳"}
                    province = extractValue(arguments, "province");
                    city = extractValue(arguments, "city");
                }

                logger.info("解析后的参数：province={}, city={}", province, city);

                if (province == null || city == null) {
                    throw new IllegalArgumentException("无法解析参数：" + arguments);
                }

                WeatherInfo weatherInfo = weatherTools.getWeather(province, city);
                return weatherInfo.toString();
            } else {
                return "Unknown tool: " + request.name();
            }
        } catch (Exception e) {
            logger.error("工具执行失败", e);
            return "Tool execution failed: " + e.getMessage();
        }
    }

    /**
     * 从 JSON 字符串中提取值
     */
    private String extractValue(String json, String key) {
        int start = json.indexOf('"' + key + '"');
        if (start == -1)
            return null;

        int colon = json.indexOf(':', start);
        int valueStart = json.indexOf('"', colon);
        int valueEnd = json.indexOf('"', valueStart + 1);

        return valueStart != -1 && valueEnd != -1 ? json.substring(valueStart + 1, valueEnd) : null;
    }

    /**
     * 通过提示词range大模型返回JSON格式的内容
     * 
     * @param prompt
     * @return
     */
    public String getWeather(String prompt) {
        List<ToolSpecification> toolSpecifications = prepareToolSpecifications();

        ChatRequest req = ChatRequest.builder()
                .messages(UserMessage.from(prompt))
                .toolSpecifications(toolSpecifications)
                .build();

        ChatResponse resp = openAiChatModel.chat(req);

        logger.info("初始响应：" + resp);

        // 检查是否需要执行工具调用
        if (resp.aiMessage().toolExecutionRequests() != null && !resp.aiMessage().toolExecutionRequests().isEmpty()) {
            logger.info("需要执行工具调用");

            // 执行所有工具调用
            for (ToolExecutionRequest toolRequest : resp.aiMessage().toolExecutionRequests()) {
                String toolResult = executeTool(toolRequest);

                logger.info("工具执行结果：" + toolResult);

                // 将工具执行结果发送回模型
                ChatRequest toolResultRequest = ChatRequest.builder()
                        .messages(
                                UserMessage.from(prompt),
                                resp.aiMessage(),
                                ToolExecutionResultMessage.from(toolRequest, "工具执行结果：" + toolResult))
                        .toolSpecifications(toolSpecifications)
                        .build();

                resp = openAiChatModel.chat(toolResultRequest);
                logger.info("工具执行后的响应：" + resp);
            }
        }

        return resp.aiMessage().text() + "[from low level getWeather]";
    }
}
  • 上述代码的重点如下：
  1. 整个功能由getWeather方法实现，该方法会被controller中的接口实现调用，入参就是用户的提示词
  2. 请求LLM的办法是执行：openAiChatModel.chat
  3. 解析第一次LLM响应再根据响应调用本地函数，这些都被封装在executeTool方法中
  4. 有一处需要重点关注的代码，如下图黄框所示，也就是说第二次请求必须要带上提示词，否则难以得到理想结果
  5. executeTool方法中还有个细节，就是LLM返回的参数信息，其参数名可能不是咱们函数的入参名称，例如这里就是arg0和arg1，所以不能只用province和city去解析
  • 最后是controller类，这里准备个http接口响应，用来调用前的服务类的功能
java 复制代码 
package com.bolingcavalry.controller;

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.bolingcavalry.service.QwenService;

import lombok.Data;

/**
 * 通义千问控制器，处理与大模型交互的HTTP请求
 */
@RestController
@RequestMapping("/api/qwen")
public class QwenController {

    private final QwenService qwenService;

    /**
     * 构造函数，通过依赖注入获取QwenService实例
     * 
     * @param qwenService QwenService实例
     */
    public QwenController(QwenService qwenService) {
        this.qwenService = qwenService;
    }

    /**
     * 提示词请求实体类
     */
    @Data
    static class PromptRequest {
        private String prompt;
        private int userId;

        private String province;
        private String city;
    }

    /**
     * 响应实体类
     */
    @Data
    static class Response {
        private String result;

        public Response(String result) {
            this.result = result;
        }
    }

    /**
     * 检查请求体是否有效
     * 
     * @param request 包含提示词的请求体
     * @return 如果有效则返回null，否则返回包含错误信息的ResponseEntity
     */
    private ResponseEntity<Response> check(PromptRequest request) {
        if (request == null || request.getPrompt() == null || request.getPrompt().trim().isEmpty()) {
            return ResponseEntity.badRequest().body(new Response("提示词不能为空"));
        }
        return null;
    }

    @PostMapping("/tool/low/getwether")
    public ResponseEntity<Response> getWeather(@RequestBody PromptRequest request) {
        ResponseEntity<Response> checkRlt = check(request);
        if (checkRlt != null) {
            return checkRlt;
        }
        try {
            Object response = qwenService.getWeather(request.getPrompt());
            return ResponseEntity.ok(new Response(response.toString()));
        } catch (Exception e) {
            // 捕获异常并返回错误信息
            return ResponseEntity.status(500).body(new Response("请求处理失败: " + e.getMessage()));
        }
    }
}
  • 至此代码就全部写完了，现在把工程运行起来试试，在tools-low-level目录下执行以下命令即可启动服务
bash 复制代码 
mvn spring-boot:run
  • 用vscode的 REST Client插件发起http请求，参数如下，和前文用提示词指定JSON不同，这里并没有要求LLM返回JSON格式
bash 复制代码 
### 查询天气，内部实现是低级API
POST http://localhost:8080/api/qwen/tool/low/getwether
Content-Type: application/json
Accept: application/json

{
  "prompt": "深圳天气"
}
  • 收到响应如下，可见与LLM对话就能得知最新的天气情况
bash 复制代码 
HTTP/1.1 200 OK
Content-Type: application/json
Transfer-Encoding: chunked
Date: Thu, 08 Jan 2026 09:15:30 GMT
Connection: close

{
  "result": "深圳当前天气情况如下：\n\n- **当前温度**：17.2℃，体感温度为15.1℃。\n- **天气状况**：晴天。\n- **湿度**：24%。\n- **风向与风力**：东北风，风速2级，微风。\n- **气压**：1015 hPa。\n- **降水**：无降水。\n\n今天白天到夜间天气均为晴，白天气温最高约18℃，夜间最低约9℃。白天风向为东北风，风力3~4级，夜间转为无持续风向，微风。适合外出活动，但注意早晚温差较大，适当增减衣物。[from low level getWeather]"
}
  • 再看日志，可见LLM第一次响应会提醒业务侧应该执行的函数及其方法，第二次请求就带上了函数结果，这样第二次LLM返回的就是根据题词要求从函数结果中整理出来的内容，这些内容源自函数结果，但是被LLM整理了一番，这就是用户最终拿到的结果
bash 复制代码 
12:16:47.177 [http-nio-8080-exec-4] INFO  c.bolingcavalry.service.QwenService - 发到LLM的请求: [UserMessage { name = null, contents = [TextContent { text = "深圳天气" }], attributes = {} }]
12:16:50.888 [http-nio-8080-exec-4] INFO  c.bolingcavalry.service.QwenService - LLM响应, 执行函数[getWeather], 函数入参 : {"arg0": "广东", "arg1": "深圳"}
12:16:50.888 [http-nio-8080-exec-4] INFO  c.bolingcavalry.service.QwenService - 初始响应：ChatResponse { aiMessage = AiMessage { text = null, thinking = null, toolExecutionRequests = [ToolExecutionRequest { id = "call_b4023a85fe464623b28f59ae", name = "getWeather", arguments = "{"arg0": "广东", "arg1": "深圳"}" }], attributes = {} }, metadata = OpenAiChatResponseMetadata{id='chatcmpl-a6629086-3c80-9dce-a610-a267f121719d', modelName='qwen3-max', tokenUsage=OpenAiTokenUsage { inputTokenCount = 296, inputTokensDetails = OpenAiTokenUsage.InputTokensDetails { cachedTokens = 0 }, outputTokenCount = 33, outputTokensDetails = null, totalTokenCount = 329 }, finishReason=TOOL_EXECUTION, created=1767874607, serviceTier='null', systemFingerprint='null', rawHttpResponse=dev.langchain4j.http.client.SuccessfulHttpResponse@1949264d, rawServerSentEvents=[]} }
12:16:50.888 [http-nio-8080-exec-4] INFO  c.bolingcavalry.service.QwenService - 需要执行工具调用
12:16:50.888 [http-nio-8080-exec-4] INFO  c.bolingcavalry.service.QwenService - 执行工具调用：getWeather，参数：{"arg0": "广东", "arg1": "深圳"}
12:16:50.888 [http-nio-8080-exec-4] INFO  c.bolingcavalry.service.QwenService - 解析后的参数：province=广东, city=深圳
12:16:50.888 [http-nio-8080-exec-4] INFO  c.bolingcavalry.service.WeatherTools - 调用天气接口：https://cn.apihz.cn/api/tianqi/tqyb.php?id=10011856&key=b860cf8c32bc224c1003078105ef43e4&sheng=%E5%B9%BF%E4%B8%9C&place=%E6%B7%B1%E5%9C%B3
12:16:51.169 [http-nio-8080-exec-4] INFO  c.bolingcavalry.service.QwenService - 工具执行结果：WeatherInfo(code=200, guo=中国, sheng=广东, shi=深圳, name=深圳, weather1=晴, weather2=晴, wd1=18, wd2=9, winddirection1=东北风, winddirection2=无持续风向, windleve1=3~4级, windleve2=微风, weather1img=https://rescdn.apihz.cn/resimg/tianqi/qing.png, weather2img=https://rescdn.apihz.cn/resimg/tianqi/qing.png, lon=114.0, lat=22.54, uptime=2026-01-08 20:00:00, nowinfo=NowInfo(precipitation=0.0, temperature=13.3, pressure=1017, humidity=33, windDirection=东北风, windDirectionDegree=3, windSpeed=1, windScale=微风, feelst=11.9, uptime=2026/01/08 19:35), alarm=null)
12:16:51.170 [http-nio-8080-exec-4] INFO  c.bolingcavalry.service.QwenService - 发到LLM的请求: [UserMessage { name = null, contents = [TextContent { text = "深圳天气" }], attributes = {} }, AiMessage { text = null, thinking = null, toolExecutionRequests = [ToolExecutionRequest { id = "call_b4023a85fe464623b28f59ae", name = "getWeather", arguments = "{"arg0": "广东", "arg1": "深圳"}" }], attributes = {} }, ToolExecutionResultMessage { id = "call_b4023a85fe464623b28f59ae" toolName = "getWeather" text = "工具执行结果：WeatherInfo(code=200, guo=中国, sheng=广东, shi=深圳, name=深圳, weather1=晴, weather2=晴, wd1=18, wd2=9, winddirection1=东北风, winddirection2=无持续风向, windleve1=3~4级, windleve2=微风, weather1img=https://rescdn.apihz.cn/resimg/tianqi/qing.png, weather2img=https://rescdn.apihz.cn/resimg/tianqi/qing.png, lon=114.0, lat=22.54, uptime=2026-01-08 20:00:00, nowinfo=NowInfo(precipitation=0.0, temperature=13.3, pressure=1017, humidity=33, windDirection=东北风, windDirectionDegree=3, windSpeed=1, windScale=微风, feelst=11.9, uptime=2026/01/08 19:35), alarm=null)" }]
12:16:59.191 [http-nio-8080-exec-4] INFO  c.bolingcavalry.service.QwenService - LLM响应, 纯文本 : 深圳当前天气情况如下：

- **当前温度**：13.3°C，体感温度为11.9°C。
- **天气状况**：晴。
- **湿度**：33%。
- **风向与风速**：东北风，风速1级，微风。
- **气压**：1017 hPa。
- **降水**：无降水。

**今日天气预报**：
- 白天：晴，气温18°C，东北风3~4级。
- 夜间：晴，气温9°C，无持续风向，微风。

如需更多天气信息，请随时告诉我！
12:16:59.191 [http-nio-8080-exec-4] INFO  c.bolingcavalry.service.QwenService - 工具执行后的响应：ChatResponse { aiMessage = AiMessage { text = "深圳当前天气情况如下：

- **当前温度**：13.3°C，体感温度为11.9°C。
- **天气状况**：晴。
- **湿度**：33%。
- **风向与风速**：东北风，风速1级，微风。
- **气压**：1017 hPa。
- **降水**：无降水。

**今日天气预报**：
- 白天：晴，气温18°C，东北风3~4级。
- 夜间：晴，气温9°C，无持续风向，微风。

如需更多天气信息，请随时告诉我！", thinking = null, toolExecutionRequests = [], attributes = {} }, metadata = OpenAiChatResponseMetadata{id='chatcmpl-8c48ff4c-650e-90a1-80bd-3182c7be2b00', modelName='qwen3-max', tokenUsage=OpenAiTokenUsage { inputTokenCount = 591, inputTokensDetails = OpenAiTokenUsage.InputTokensDetails { cachedTokens = 0 }, outputTokenCount = 139, outputTokensDetails = null, totalTokenCount = 730 }, finishReason=STOP, created=1767874611, serviceTier='null', systemFingerprint='null', rawHttpResponse=dev.langchain4j.http.client.SuccessfulHttpResponse@78a1c261, rawServerSentEvents=[]} }

思考：函数调用有意义吗？

  • 回看前面的功能：想知道天气，直接调用天气接口就行，结果还要和LLM对话，而且对话期间还要去调接口查天气信息，这算不算脱了裤子放Pi？
  • 判断函数调用是不是多余的，咱们再看一个例子，请求如下
bash 复制代码 
### 查询天气，内部实现是低级API
POST http://localhost:8080/api/qwen/tool/low/getwether
Content-Type: application/json
Accept: application/json

{
  "prompt": "深圳今天下雨吗?不要其他信息"
}
  • 响应如下
bash 复制代码 
HTTP/1.1 200 OK
Content-Type: application/json
Transfer-Encoding: chunked
Date: Thu, 08 Jan 2026 09:20:02 GMT
Connection: close

{
  "result": "深圳今天不下雨，天气为晴。[from low level getWeather]"
}
  • 看了上面的问答，想必您已经发现了：接口不用变化，但是利用LLM的理解能力，我们可以有多种问法，也能得到多种回复，相当于核心数据可以延伸到更多的业务场景
  • 至此，低级API版本的函数调用学习完成，是不是感觉代码量略大？而且啥事都靠自己写代码实现太累了，下一篇，咱们就来体验高级API版本的函数调用，整个过程会非常轻松，因为这些你觉得该封装的东西，LangChain4j都帮忙我们封装在AiService中了

你不孤单，欣宸原创一路相伴

  1. Java系列
  2. Spring系列
  3. Docker系列
  4. kubernetes系列
  5. 数据库+中间件系列
  6. DevOps系列
相关推荐
charlie1145141912 小时前
从 0 开始的机器学习——NumPy 线性代数部分
开发语言·人工智能·学习·线性代数·算法·机器学习·numpy
Java新手村2 小时前
【订单超时取消怎么设计】
java
咚咚王者2 小时前
人工智能之核心基础 机器学习 第十二章 半监督学习
人工智能·学习·机器学习
人工智能训练2 小时前
UE5 如何显示蓝图运行流程
人工智能·ue5·ai编程·数字人·蓝图
deephub2 小时前
构建自己的AI编程助手：基于RAG的上下文感知实现方案
人工智能·机器学习·ai编程·rag·ai编程助手
阿蒙Amon2 小时前
C#每日面试题-常量和只读变量的区别
java·面试·c#
AI营销干货站3 小时前
工业B2B获客难？原圈科技解析2026五大AI营销增长引擎
人工智能
程序员老刘·3 小时前
重拾Eval能力：D4rt为Flutter注入AI进化基因
人工智能·flutter·跨平台开发·客户端开发
kebijuelun3 小时前
FlashInfer-Bench：把 AI 生成的 GPU Kernel 放进真实 LLM 系统的“闭环引擎”
人工智能·gpt·深度学习·机器学习·语言模型
热门推荐
01GitHub 镜像站点02网站改了域名，如何查找？03Labelme从安装到标注：零基础完整指南04Linux下V2Ray安装配置指南05AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南062025-04-03 Latex学习1——本地配置Latex + VScode环境07安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）08【踩坑笔记】50系显卡适配的 PyTorch 安装09百度网盘偷偷给电脑“降频”？10Overleaf编译超时，超出免费计划编译时限（已解决）