springboot调用大模型 （调用LM Studio大模型）

一.调用LM Studio大模型(推荐)

推荐理由：有可视化界面，大模型库全面，维护方便，对windows用户友好，模型迁移方便（迁移时直接复制粘贴即可），多模态大模型支持特别友好，接口参数固定（目前是）

缺点：更新频繁，模型下载过慢，似乎对linux操作系统不是特别友好，模型下载往往需要下载一天（可能下载失败）

1.下载LM Studio

官网：https://lmstudio.ai/

2.安装

3.切换语言

4.下载选择

5.调试模型

上下文长度按需求调整，调整到你适用的场景，上下文长度太短，会报错

6.开始加载模型

Status一定要开启，要不然无法调用模型，端口默认1234，可以修改

7.添加依赖

     <!-- AsyncHttpClient -->
        <dependency>
            <groupId>org.asynchttpclient</groupId>
            <artifactId>async-http-client</artifactId>
            <version>2.12.3</version>
        </dependency>
    </dependencies>


    <!-- JSON 处理库 -->
        <dependency>
            <groupId>org.json</groupId>
            <artifactId>json</artifactId>
            <version>20231013</version> <!-- 使用最新版本 -->
        </dependency>

8.开始调用（多模态调用，支持各种图片包括Tiff，tif，pdf需要转换）

import org.asynchttpclient.*;
import org.json.JSONArray;
import org.json.JSONObject;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.Base64;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;

public class LMStudioService {
    private static final String BASE_URL = "http://localhost:1234";
    private static final String CHAT_ENDPOINT = "/v1/chat/completions";

    // 创建异步HTTP客户端
    private static final AsyncHttpClient asyncHttpClient = Dsl.asyncHttpClient(
            Dsl.config()
                    .setConnectTimeout(300000)          // 连接建立超时时间（毫秒）
                    .setRequestTimeout(600000)          // 整个请求超时时间（毫秒）
                    .setReadTimeout(600000)             // 读取数据超时时间（毫秒）
                    .setMaxConnections(1000)            // 最大连接数
                    .setMaxConnectionsPerHost(500)      // 每个主机最大连接数
    );

    public static void main(String[] args) {
        try {
            // 1. 读取图片并转换为Base64
            List<String> imagePaths = new ArrayList<>();
            imagePaths.add("C:\\Users\\wwb\\Desktop\\img\\测试.jpg");
            //支持传入多张图片，但是不太建议（太多模型会太卡，模型反应速度会很慢，建议一到两张图片）

            String response = sendMultimodalChatRequest(imagePaths, "请给我描述一下第一张图片");

            System.out.println("AI响应: " + response);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                asyncHttpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 将图片转换为Base64字符串
     */
    public static String convertTiffToBase64(String tifPath, int page) throws Exception {
        // 读取TIF（需JDK支持TIFF插件）
        BufferedImage tiffImage = ImageIO.read(new File(tifPath));

        // 多页处理（示例仅取第一页）
        // 实际需用 ImageReader 迭代页面

        // 转换为PNG
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ImageIO.write(tiffImage, "png", baos);

        // Base64编码
        return Base64.getEncoder().encodeToString(baos.toByteArray());
    }

    /**
     * 发送多模态聊天请求（使用Base64图片）- 异步方式
     */
    public static String sendMultimodalChatRequest(List<String> imagePaths, String prompt)
            throws Exception {

        // 构建请求体
        JSONObject requestBody = new JSONObject();
//        requestBody.put("model", "minicpm-v-4_5");
        //此处为模型全称你
        requestBody.put("model", "huihui-minicpm-v-4_5-abliterated");


        JSONArray messages = new JSONArray();
        JSONObject message = new JSONObject();
        message.put("role", "user");

        JSONArray content = new JSONArray();

        // 添加文本内容
        JSONObject textContent = new JSONObject();
        textContent.put("type", "text");
        textContent.put("text", prompt);
        content.put(textContent);

        // 添加图片内容（Base64格式）
        for (String imagePath : imagePaths) {
            String base64Image = convertTiffToBase64(imagePath, 0);

            JSONObject imageContent = new JSONObject();
            imageContent.put("type", "image_url");

            // 构建image_url对象
            JSONObject imageUrl = new JSONObject();
            imageUrl.put("url", "data:image/jpeg;base64," + base64Image);

            imageContent.put("image_url", imageUrl);
            content.put(imageContent);
        }

        message.put("content", content);
        messages.put(message);

        requestBody.put("messages", messages);
        requestBody.put("max_tokens", 1000);

        // 创建异步请求
        CompletableFuture<String> future = asyncHttpClient
                .preparePost(BASE_URL + CHAT_ENDPOINT)
                .setHeader("Content-Type", "application/json")
                .setBody(requestBody.toString())
                .execute()
                .toCompletableFuture()
                .thenApply(response -> {
                    try {
                        JSONObject jsonResponse = new JSONObject(response.getResponseBody());
                        return jsonResponse.getJSONArray("choices")
                                .getJSONObject(0)
                                .getJSONObject("message")
                                .getString("content");
                    } catch (Exception e) {
                        throw new RuntimeException("Failed to parse response", e);
                    }
                });

        // 等待结果
        return future.get();
    }
}