SpringBoot集成Milvus|（实现向量的存储和查询）_springboot milvus

SpringBoot集成Milvus|（实现向量的存储和查询）

---

文章目录

• SpringBoot集成Milvus|（实现向量的存储和查询）
• • @[TOC]
• 前言
• 一、Milvus介绍
• 二、Milvus数据库安装
• • 1.Milvus安装环境准备（centos7）
  • 2.Milvus客户端安装
  • 3.attu新建Milvus集合
• 三、Milvus集成
• • 1.依赖引入
  • 2.客户端初始化
  • 3.代码创建集合示例
• 总结

章节
第一章链接: SpringBoot集成Milvus|（实现向量的存储和查询）

前言

随着互联网不断发展，电子邮件、论文、物联网传感数据、社交媒体照片、蛋白质分子结构等非结构化数据已经变得越来越普遍。如果想要使用计算机来处理这些数据，需要使用 embedding 技术将这些数据转化为向量。随后，Milvus 会存储这些向量，并为其建立索引。Milvus 能够根据两个向量之间的距离来分析他们的相关性。如果两个向量十分相似，这说明向量所代表的源数据也十分相似

一、Milvus介绍

Milvus 是一款云原生向量数据库，它具备高可用、高性能、易拓展的特点，用于海量向量数据的实时召回。
Milvus 基于 FAISS、Annoy、HNSW 等向量搜索库构建，核心是解决稠密向量相似度检索的问题。在向量检索库的基础上，Milvus 支持数据分区分片、数据持久化、增量数据摄取、标量向量混合查询、time travel 等功能，同时大幅优化了向量检索的性能，可满足任何向量检索场景的应用需求。通常，建议用户使用 Kubernetes 部署 Milvus，以获得最佳可用性和弹性。

二、Milvus数据库安装

1.Milvus安装环境准备（centos7）

1、服务器需要部署docker以及docker-compose
2、新建一个工作目录
3、获取Milvus的安装启动YAML文件
4、获取文件wget https://github.com/milvus-io/milvus/releases/download/v2.1.4/milvus-standalone-docker-compose.yml -O docker-compose.yml
5、启动docker镜像 sudo docker-compose up -d
6、启动后容器情况

7、停止Milvus容器
sudo docker-compose down

2.Milvus客户端安装

1、在docker仓库中找到Milvus对应版本的客户端镜像
2、拉取镜像;docker pull zilliz/attu:v2.1.0
3、运行attu
docker run -itd --restart=always -p 13000:3000 -e HOST_URL=http://{ip}:13000 -e MILVUS_URL={ip}:19530 zilliz/attu:v2.1.0
ip为部署ip
4、浏览器登陆访问：http://{ip}::13000

3.attu新建Milvus集合

新建集合名称为content3，字段id是主键，content存的是内容对应的文本id，content_intro存的是内容向量

新建pattion
content3_partion为新建的分区

三、Milvus集成

1.依赖引入

java操作Milvus的组件工具

    <!-- milvus向量数据库  -->
   <dependency>
       <groupId>io.milvus</groupId>
       <artifactId>milvus-sdk-java</artifactId>
       <version>2.2.4</version>
       <exclusions>
           <exclusion>
               <groupId>org.apache.logging.log4j</groupId>
               <artifactId>log4j-slf4j-impl</artifactId>
           </exclusion>
       </exclusions>
   </dependency>

2.客户端初始化

初始化客户端使用实例，放入容器

@Configuration
public class MilvusConfig {

    @Value("${milvus.host}")
    private String host;
    @Value("${milvus.port}")
    private Integer port;

    @Bean
    public MilvusServiceClient milvusServiceClient() {
        return new MilvusServiceClient(
                ConnectParam.newBuilder()
                        .withHost(host)
                        .withPort(port)
                        .build());
    }
}

3.代码创建集合示例

代码初始化集合结构

public class PushMaterielsConst {
    /**
     * 集合名称(库名)
     */
    public static final String COLLECTION_NAME = "content3";

    public static final String PARTITION_NAME = "content3_partion";

    /**
     * 分片数量
     */
    public static final Integer SHARDS_NUM = 1;
    /**
     * 分区数量
     */
    public static final Integer PARTITION_NUM = 1;

    /**
     * 分区前缀
     */
    public static final String PARTITION_PREFIX = "shards_";
    /**
     * 向量值长度
     */
    public static final Integer FEATURE_DIM = 256;

    public static final Boolean TRUE = true;

    /**
     * 字段
     */
    public static class Field {
        /**
         * 主键idID
         */
        public static final String ID = "id";
        /**
         * 文本id
         */
        public static final String CONTENT = "content";
        /**
         * 向量值
         */
        public static final String CONTENT_INTRO = "content_intro";
    }


}

创建结合代码

 public void creatCollection() {
        FieldType fieldType1 = FieldType.newBuilder()
                .withName(PushMaterielsConst.Field.ID)
                .withDataType(DataType.Int64)
                .withPrimaryKey(true)
                .withAutoID(false)
                .build();
        FieldType fieldType2 = FieldType.newBuilder()
                .withName(PushMaterielsConst.Field.CONTENT)
                .withDataType(DataType.VarChar)
                .withMaxLength(255)
                .build();
        FieldType fieldType3 = FieldType.newBuilder()
                .withName(PushMaterielsConst.Field.CONTENT_INTRO)
                .withDataType(DataType.FloatVector)
                .withDimension(2)
                .build();
        CreateCollectionParam createCollectionReq = CreateCollectionParam.newBuilder()
                .withCollectionName(PushMaterielsConst.COLLECTION_NAME)
                .withDescription("user content search")
                .withShardsNum(2)
                .addFieldType(fieldType1)
                .addFieldType(fieldType2)
                .addFieldType(fieldType3)
                .build();
        MilvusServiceClient milvusClient = getClient();
        R<RpcStatus> response = milvusClient.createCollection(createCollectionReq);
        log.info(PushMaterielsConst.COLLECTION_NAME + "是否成功创建集合——>>" + response.getStatus());
    }

插入数据代码

  /**
     * 插入数据
     *
     * @param milvusParamVoList
     * @return
     */
    public void insertPrepare(List<MilvusParamBo> milvusParamVoList) {
        List<String> content_array = new ArrayList<>();
        List<List<Float>> vector_array = new ArrayList<>();
        for (MilvusParamBo vo : milvusParamVoList) {
            content_array.add(vo.getContentId());
            vector_array.add(vo.getVector());
        }

        List<InsertParam.Field> fields = new ArrayList<>();
        fields.add(new InsertParam.Field(PushMaterielsConst.Field.CONTENT, content_array));
        fields.add(new InsertParam.Field(PushMaterielsConst.Field.CONTENT_INTRO, vector_array));

        InsertParam insertParam = InsertParam.newBuilder()
                .withCollectionName(PushMaterielsConst.COLLECTION_NAME)
                .withPartitionName(PushMaterielsConst.PARTITION_NAME)
                .withFields(fields)
                .build();
        R<MutationResult> insert = milvusClient.insert(insertParam);
        Integer status = insert.getStatus();
        System.out.println("数据插入状态：" + status);
    }

查询数据代码

    public List<String> searchTallestSimilarity(List<Float> arcsoftToFloat) {
        log.info("----Milvus数据加载到内存------");
        loadCollection();
        List<List<Float>> list = new ArrayList<>();
        list.add(arcsoftToFloat);
        SearchParam searchParam = SearchParam.newBuilder()
                //集合名称
                .withCollectionName(PushMaterielsConst.COLLECTION_NAME)
                .withPartitionNames(Arrays.asList(PushMaterielsConst.PARTITION_NAME))
                //计算方式
                // 欧氏距离 (L2)
                // 内积 (IP)
                .withMetricType(MetricType.L2)
                .withOutFields(Arrays.asList(PushMaterielsConst.Field.CONTENT))
                //返回多少条结果
                .withTopK(5)
                //搜索的向量值
                .withVectors(list)
                //搜索的Field
                .withVectorFieldName(PushMaterielsConst.Field.CONTENT_INTRO)
                .withParams(SEARCH_PARAM)
                .build();

        log.info("----Milvus向量搜索------");
        R<SearchResults> search = milvusClient.search(searchParam);
        log.info("----搜索数据处理------");
        if (search.getData() == null) return null;
        List<String> returnList = Lists.newArrayList();
        SearchResultsWrapper wrapper = new SearchResultsWrapper(search.getData().getResults());
        for (int i = 0; i < list.size(); i++) {
            List<?> fieldData = wrapper.getFieldData(PushMaterielsConst.Field.CONTENT, i);
            for (int j = 0; j < fieldData.size(); j++) {
                returnList.add((String) fieldData.get(j));
            }
        }
        return returnList;
    }
    public void loadCollection() {
        log.info("----Milvus加载到内存------");
        R<RpcStatus> response = milvusClient.loadPartitions(
                LoadPartitionsParam
                        .newBuilder()
                        //集合名称
                        .withCollectionName(PushMaterielsConst.COLLECTION_NAME)
                        //需要加载的分区名称
                        .withPartitionNames(Lists.newArrayList(PushMaterielsConst.PARTITION_NAME))
                        .build());
        log.info("Milvus数据加载到内存状态：{}", response.getStatus());
    }

按照多条件匹配查询数据

      public List<MilvesSearchDate> searchTallestSimilarityWithExpr(List<Float> arcsoftToFloat, ContentParamVo paramVo,
                                                                  String collectionName, String partionName) {
        Integer top = paramVo.getTop();
        if (top == null || top < 1) {
            top = 5;
        }
        loadCollection(collectionName, partionName);

        // 查询参数封装
        //1、向量查询参数
        List<List<Float>> list = new ArrayList<>();
        list.add(arcsoftToFloat);
        SearchParam.Builder builder = SearchParam.newBuilder()
                //集合名称
                .withCollectionName(collectionName)
                .withPartitionNames(Arrays.asList(partionName))
                //计算方式
                // 欧氏距离 (L2)
                // 内积 (IP)
                .withMetricType(MetricType.L2)
                .withOutFields(Arrays.asList(MilvusFileId.PARTID))
                //返回多少条结果
                .withTopK(top)
                //搜索的向量值
                .withVectors(list)
                //搜索的Field
                .withVectorFieldName(MilvusFileId.EMBEDDING)
                .withParams(SEARCH_PARAM);
//                .withExpr();
        //2、类别查询参数
        List<String> categorys = paramVo.getCategoryId();
        if (categorys != null && categorys.size() > 0) {
            String categoryExpr = StringUtils.join(MilvusFileId.CATEGORY, " in [", listToString(categorys), "]");
            log.info("过滤条件：{}", categoryExpr);
            builder.withExpr(categoryExpr);
        }
        //3、文章id查询参数
        List<String> docs = paramVo.getDocId();
        if (docs != null && docs.size() > 0) {
            String docExpr = StringUtils.join(MilvusFileId.DOCID, " in [", listToString(docs), "]");
            log.info("过滤条件：{}", docExpr);
            builder.withExpr(docExpr);
        }
        log.info("----Milvus向量搜索------");
        R<SearchResults> search = milvusClient.search(builder.build());
        log.info("----搜索数据处理------");
        if (search.getData() == null) {
            log.error("搜索数据返回为空");
            return null;
        }
        List<MilvesSearchDate> returnList = Lists.newArrayList();
        SearchResultsWrapper wrapper = new SearchResultsWrapper(search.getData().getResults());
        try {
            for (int i = 0; i < list.size(); i++) {
                List<SearchResultsWrapper.IDScore> scores = wrapper.getIDScore(i);
                List<?> fieldData = wrapper.getFieldData(MilvusFileId.PARTID, i);
                for (int j = 0; j < fieldData.size(); j++) {
                    returnList.add(MilvesSearchDate.builder()
                            .partId((String) fieldData.get(j))
                            .score(scores.get(j).getScore())
                            .build());
                }
            }
        } catch (Exception e) {
            log.error("解析向量匹配数据异常：{}", e.getMessage());
        }
        return returnList;
    }

总结

上述为springboot集成Milvus数据库的实现，查询的时候存在问题，如果查询的写了前五条数据，实际只查询到3条的话，剩下的两天就会乱给（给的数据和查询文本不相干）