Doubao引擎注册及获取免费服务

注册Doubao账号并登录控制台，进入AI服务管理页面。选择向量引擎和对话引擎服务，按照指引完成开通流程。免费额度通常包括一定量的API调用次数和存储空间，具体限制需查阅官方文档。

Java连接Milvus的方法

参考已发布的文章《Java 对接 Milvus 向量数据库从 0 到 1》，该文详细介绍了依赖配置、客户端初始化及基本操作示例。重点包含：

• 下载milvus镜像部署
• 引入milvus-sdk-java依赖
• 配置milvus连接参数

1. Java连接豆包API

1.1 对话API接入

示例核心步骤：

1. 配置doubaoConfig 类, 并于yaml文件中进行相应配置
 

package com.example.demo.config;

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

/**
 * 豆包config 类
 *
 * @Author 无力的研究者
 */

@Configuration
@Data
public class DoubaoSeedConfig {

     // 豆包引擎
    @Value("${doubao.model}")
    private String model;
    // 角色
    @Value("${doubao.role}")
    private String role;
     // 豆包引擎 apiKey 秘钥
    @Value("${doubao.apiKey}")
    private String apiKey;
    /**
     * 普通对话api
     */
    @Value("${doubao.apiUrl}")
    private String apiUrl;
    /**
     * 流式对话api
     */
    @Value("${doubao.apiStreamUrl}")
    private String apiStreamUrl;
    /**
     * 向量api
     */
    @Value("${doubao.embeddingsUrl}")
    private String embeddingsUrl;

     // 向量引擎
    @Value("${doubao.embeddingsModel}")
    private String embeddingsModel;
}

2. 进行豆包工具类的编写, 实现可以通过提示词,调用对话API获取回答.

package com.example.demo.utils;

import com.example.demo.config.DoubaoSeedConfig;
import com.volcengine.ark.runtime.model.multimodalembeddings.MultimodalEmbeddingInput;
import com.volcengine.ark.runtime.model.multimodalembeddings.MultimodalEmbeddingRequest;
import com.volcengine.ark.runtime.model.multimodalembeddings.MultimodalEmbeddingResult;
import com.volcengine.ark.runtime.model.responses.content.OutputContentItem;
import com.volcengine.ark.runtime.model.responses.content.OutputContentItemText;
import com.volcengine.ark.runtime.model.responses.item.BaseItem;
import com.volcengine.ark.runtime.model.responses.item.ItemOutputMessage;
import com.volcengine.ark.runtime.model.responses.request.CreateResponsesRequest;
import com.volcengine.ark.runtime.model.responses.request.ResponsesInput;
import com.volcengine.ark.runtime.model.responses.response.ResponseObject;
import com.volcengine.ark.runtime.service.ArkService;
import okhttp3.ConnectionPool;
import okhttp3.Dispatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * 豆包工具类(自写方法)
 *
 * @Author 无力的研究者
 */

@Component
public class DouBaoUtil {

    @Autowired
    private static DoubaoSeedConfig doubaoSeedConfig;

    /**
     * 获取回复
     * @param questMes  问题
     * @return 回复
     */
    public static String getQuest(String questMes) {
        ArkService arkService = ArkService.builder().apiKey(doubaoSeedConfig.getApiKey()).baseUrl(doubaoSeedConfig.getApiUrl()).build();
        CreateResponsesRequest request = CreateResponsesRequest.builder()
                .model(doubaoSeedConfig.getModel())
                .input(ResponsesInput.builder().stringValue(questMes).build())
                .build();


        ResponseObject resp = arkService.createResponse(request);
//        System.out.println(resp);
        List<BaseItem> outputItems = resp.getOutput();
        if (outputItems != null && !outputItems.isEmpty()) {
            // 2. 遍历查找类型为 'message' 的项 (即 ItemOutputMessage)
            for (BaseItem item : outputItems) {
                // 判断是否为消息类型，避开 reasoning 类型
                if (item instanceof ItemOutputMessage) {
                    ItemOutputMessage message = (ItemOutputMessage) item;

                    // 3. 获取 content 列表
                    List<OutputContentItem> contents = message.getContent();
                    if (contents != null && !contents.isEmpty()) {
                        for (OutputContentItem contentItem : contents) {
                            // 4. 判断是否为文本类型
                            if (contentItem instanceof OutputContentItemText) {
                                OutputContentItemText textItem = (OutputContentItemText) contentItem;
                                String finalText = textItem.getText();
                                arkService.shutdownExecutor();
                                return finalText;
                            }
                        }
                    }
                }
            }
        }
        arkService.shutdownExecutor();
        return "构建失败";
    }


}

1.2 向量获取API接入

       通过豆包秘钥,豆包向量api接口,豆包向量引擎,及要转换的向量文本,获取向量值,具体核心代码如下: 

    /**
     * 获取向量
     * @param text  文本
     * @return 向量
     */
    public static List<Float> generateDimVector(String apiKey, String url, String model, String text) {
        // 调用模型生成向量检索值
        ConnectionPool connectionPool = new ConnectionPool(5, 1, TimeUnit.SECONDS);
        Dispatcher dispatcher = new Dispatcher();
        ArkService embeddingsService =
                ArkService.builder()
                        .dispatcher(dispatcher)
                        .connectionPool(connectionPool)
                        .apiKey(apiKey)
                        .baseUrl(url)
                        .build();

        List<MultimodalEmbeddingInput> inputForReqList = new ArrayList<>();
        MultimodalEmbeddingInput elementForInputForReqList0 = new MultimodalEmbeddingInput();
        elementForInputForReqList0.setType("text");
        elementForInputForReqList0.setText(text);
        inputForReqList.add(elementForInputForReqList0);

        MultimodalEmbeddingRequest request =
                MultimodalEmbeddingRequest.builder()
                        .model(model)
                        .input(inputForReqList)
                        .build();

        MultimodalEmbeddingResult multiModalEmbeddings = embeddingsService.createMultiModalEmbeddings(request);
        List<Double> embedding = multiModalEmbeddings.getData().getEmbedding();

        // 3. 转换为 List<Float> (Milvus Java SDK 通常要求 List<Float>)
        if (embedding != null) {
            embeddingsService.shutdownExecutor();
            return embedding.stream()
                    .map(Double::floatValue)
                    .collect(Collectors.toList());
        }
        embeddingsService.shutdownExecutor();
        return new ArrayList<>();
    }

2. Java使用Milvus实战

2.1 java 使用 milvus 集合创建

 通过之前milvus进行连接后,直接进行集合的创建即可,在项目中,直接进行相关MilvusConfig文件进行配置连接即可,具体创建集合代码如下: 
 

String collectionName = "demo_collection";

List<FieldType> fieldsSchema = new ArrayList<>();

            // 主键 ID
            fieldsSchema.add(FieldType.newBuilder()
                    .withName("id")
                    .withDataType(DataType.Int64)
                    .withPrimaryKey(true)
                    .withAutoID(true)
                    .build());

            // 向量字段 (假设维度为 128)
            fieldsSchema.add(FieldType.newBuilder()
                    .withName("vector")
                    .withDataType(DataType.FloatVector)
                    .withDimension(2048)
                    .build());

            // 标量字段 (可选，用于过滤)
            fieldsSchema.add(FieldType.newBuilder()
                    .withName("color")
                    .withDataType(DataType.VarChar)
                    .withMaxLength(1024)
                    .build());

            // 创建集合
            CreateCollectionParam createParam = CreateCollectionParam.newBuilder()
                    .withCollectionName(collectionName)
                    .withFieldTypes(fieldsSchema)
                    .build();

            client.createCollection(createParam);
            System.out.println("✅ 集合创建成功: " + collectionName);

2.2 java 使用 milvus 向量存储

实现向量存储的典型流程：

    /**
     * demo_collection 向量添加
     *
     * @param content 值
     */
    @Override
    public boolean addVer(String content) {
        // 3.1 模拟嵌入模型生成的 768 维向量（实际开发中用 BGE 等模型生成）
        List<List<Float>> vectors = new ArrayList<>();
        List<Float> floats = DouBaoUtil.generateDimVector(doubaoSeedConfig.getApiKey(), doubaoSeedConfig.getEmbeddingsUrl(), doubaoSeedConfig.getEmbeddingsModel(), content);
        vectors.add(floats);

// 3.2 对应的文档内容（元数据）
        List<String> docContents = new ArrayList<>();
        docContents.add(content);
        return addVector(vectors, docContents);
    }

/**
     * demo_collection 向量添加
     *
     * @param vectors     向量集合
     * @param docContents 值集合对应文档内容
     */
    @Override
    public boolean addVector(List<List<Float>> vectors, List<String> docContents) {
        String collectionName = "demo_collection";

        if (vectors == null || docContents == null || vectors.size() != docContents.size()) {
            log.error("数据不匹配");
            return false;
        }

        try {
            List<InsertParam.Field> fields = new ArrayList<>();

            // 使用构造函数创建 Field 对象
            fields.add(new InsertParam.Field("vector", vectors));
            fields.add(new InsertParam.Field("color", docContents));

            InsertParam insertParam = InsertParam.newBuilder()
                    .withCollectionName(collectionName)
                    .withFields(fields)
                    .build();

            // 执行插入
            R<MutationResult> response = milvusClient.insert(insertParam);

            if (response.getStatus() != 0) {
                log.error("插入失败: {}", response.getMessage());
                return false;
            }

            // 刷新以确保数据可见
            milvusClient.flush(io.milvus.param.collection.FlushParam.newBuilder()
                    .addCollectionName(collectionName)
                    .build());

            log.info("成功插入 {} 条数据", vectors.size());
            return true;

        } catch (Exception e) {
            log.error("插入异常", e);
            return false;
        }
    }

2.3 java + milvus + 豆包引擎 实现 Ai RAG 智能对话

2.3.1 调用方法: 

/**
     * 聊天
     *
     * @param question 问题
     * @return 回复
     */
    @Override
    public String chat(String question) {
        try {
            // 原始检索
//            BasicRagDemo basicRagDemo = new BasicRagDemo();
//            String prompt = basicRagDemo.ragMain(question);
            // 向量检索
            String prompt = ragMainByQuest(question);

            log.info("检索知识库拼接成功:{}", prompt);
            return DouBaoUtil.getQuest(prompt);
        } catch (IOException e) {
            log.info("检索知识库拼接错误{}", e.getMessage());
            return DouBaoUtil.getQuest(question);
        }

2.3.2 向量检索拼接提示词 prompt

 /**
     * 带用户提问的RAG流程：检索 → 拼接prompt → 调用AI API (进阶版 使用向量数据库)
     * @param userQuestion 用户提问
     * @return AI响应内容
     * @throws IOException 网络请求异常
     */
    public String ragMainByQuest(String userQuestion) throws IOException {
        // 1. 检索相关知识点
        List<String> retrievedContent = vectorIndex(userQuestion);

        // 2. 拼接prompt（关键：让AI基于检索内容回答）
        StringBuilder prompt = new StringBuilder();
        prompt.append("请根据以下检索到的知识点，回答用户的问题，不要脱离知识点内容，语言简洁易懂：\n");
        prompt.append("检索到的知识点：\n");
        for (String content : retrievedContent) {
            prompt.append(content).append("\n");
        }
        prompt.append("用户问题：").append(userQuestion);
        // 3. 调用AI API获取响应
        return prompt.toString();
    }

以上都是个人观点,学习AI中的一些小实战,若对你有帮助的话,朋友们,动动小手点点赞!!!

关键注意事项：

• 确保Milvus服务版本与SDK兼容
• 批量操作时注意请求超时设置
• 生产环境建议实现连接池管理