笔记数据库 spring boot Springboot整合Milvus向量库

1. Milvus的Maven依赖，配置如下

io.milvus

milvus-sdk-java

2.3.4

log4j-slf4j-impl

org.apache.logging.log4j

PS: 请注意！引入的版本要看你部署的milvus服务的版本是多少，然后milvus官网上会有milvus服务对应的java sdk版本的版本号，版本号一定要对应的上这样相应的版本api文档接口才可以用

milvus官方文档：Milvus v2.3.x documentation

然后2.3.4版本的java sdk的milvus还需要引用google 的protobuf包，不然会报错提示找不到此包

此包也要注意对应milvus的版本这里官网没说明，我自行尝试可用的是3.24.1版本对应milvus的2.3.4版本的，配置如下：

com.google.protobuf

protobuf-java

3.24.1

2. 向量库的配置类获取向量库服务地址登录用户密码等

import io.milvus.client.MilvusServiceClient;

import io.milvus.param.ConnectParam;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

@Configuration

public class MilvusConfig {

@Value("${milvus.host}")

private String host;

@Value("${milvus.port}")

private Integer port;

@Value("${milvus.username}")

private String username;

@Value("${milvus.password}")

private String password;

@Bean

public MilvusServiceClient milvusServiceClient() {

return new MilvusServiceClient(

ConnectParam.newBuilder()

.withHost(host)

.withPort(port)

.withAuthorization(username, password)

.build());

}

application.yml配置文件里配置相应的数据信息

3. 根据milvus 2.3.5 java SDK提供的API接口调测相关使用的接口

如：创建集合，创建索引，加载集合到内存，插入向量数据，查询向量数据并返回结果删除集合

import java.util.List;

/**

* milvus向量数据库相关业务接口

* @author Jx

* @version 2024-3-18

public interface IMilvusService {

Boolean hasCollect(String collectionName);

void create(String collectionName, String desc);

Boolean insert(String name, List textIds, List> vectorList);

List search(String name, int topK, List> vectorList);

void dropCollect(String name);

void createIndex(String name);

void dropVectors(String name, List indexIds);

}

实现类

import com.beust.jcommander.internal.Lists;

import com.geb.config.FaceArchive;

import com.geb.service.IMilvusService;

import io.milvus.client.MilvusServiceClient;

import io.milvus.common.clientenum.ConsistencyLevelEnum;

import io.milvus.grpc.DataType;

import io.milvus.grpc.GetLoadStateResponse;

import io.milvus.grpc.MutationResult;

import io.milvus.grpc.SearchResults;

import io.milvus.param.IndexType;

import io.milvus.param.MetricType;

import io.milvus.param.R;

import io.milvus.param.RpcStatus;

import io.milvus.param.collection.*;

import io.milvus.param.dml.DeleteParam;

import io.milvus.param.dml.InsertParam;

import io.milvus.param.dml.SearchParam;

import io.milvus.param.highlevel.collection.ListCollectionsParam;

import io.milvus.param.highlevel.collection.response.ListCollectionsResponse;

import io.milvus.param.highlevel.dml.DeleteIdsParam;

import io.milvus.param.highlevel.dml.response.DeleteResponse;

import io.milvus.param.index.CreateIndexParam;

import io.milvus.response.SearchResultsWrapper;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

@Slf4j

@Service

public class MilvusServiceImpl implements IMilvusService {

@Autowired

private MilvusServiceClient milvusServiceClient;

final IndexType INDEX_TYPE = IndexType.IVF_FLAT; // IndexType

final String INDEX_PARAM = "{\"nlist\":1024}"; // ExtraParam

/**

* 创建集合的字段

* text_id 对应的文本id

* vector 向量字段

* tag 标签

private final String TEXTID = "text_id";

private final String VECTOR = "vector";

private final String TAG = "tag";

private final int dimension = 1024;

/**

* 创建集合指定集合名称

@Override

public void create(String collectionName, String desc){

log.info("Miluvs create collectionName:{}, desc:{}", collectionName, desc);

boolean has = hasCollect(collectionName);

log.info("Miluvs hasCollect:{}", has);

// 不存在此集合才进行创建集合

if(!has){

// 创建集合设置索引加载集合到内存中

FieldType fieldType1 = FieldType.newBuilder()

.withName(TEXTID)

.withDataType(DataType.Int64)

.withPrimaryKey(true)

.withAutoID(false)

.build();

FieldType fieldType2 = FieldType.newBuilder()

.withName(VECTOR) // 设置向量名称

.withDataType(DataType.FloatVector) // 设置向量类型

.withDimension(dimension) // 设置向量维度

.build();

FieldType fieldType3 = FieldType.newBuilder()

.withName(TAG)

.withDataType(DataType.Int64)

.build();

CreateCollectionParam createCollectionReq = CreateCollectionParam.newBuilder()

.withCollectionName(collectionName)

.withDescription(desc)

.withShardsNum(2)

.addFieldType(fieldType1)

.addFieldType(fieldType2)

.addFieldType(fieldType3)

.withEnableDynamicField(true)

.withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)

.build();

R response = milvusServiceClient.createCollection(createCollectionReq);

if (response.getStatus() != R.Status.Success.getCode()) {

log.info("milvus create fail message:{}", response.getMessage());

}else{

// 创建集合索引并加载集合到内存插入数据和搜索的前置操作！！

createIndex(collectionName);

}

/**

* 创建集合索引 -- 加在向量字段上

* @param collectionName

public void createIndex(String collectionName){

milvusServiceClient.createIndex(

CreateIndexParam.newBuilder()

.withCollectionName(collectionName)

.withFieldName(VECTOR)

.withIndexType(INDEX_TYPE)

.withMetricType(MetricType.L2)

.withExtraParam(INDEX_PARAM)

.withSyncMode(Boolean.FALSE)

.build()

);

// 加载所创建的集合

loadCollection(collectionName);

}

/**

* 加载集合

* @param collectionName

public void loadCollection(String collectionName){

milvusServiceClient.loadCollection(

LoadCollectionParam.newBuilder()

.withCollectionName(collectionName)

.build()

);

// You can check the loading status

GetLoadStateParam param = GetLoadStateParam.newBuilder()

.withCollectionName(collectionName)

.build();

R stateResponse = milvusServiceClient.getLoadState(param);

if (stateResponse.getStatus() != R.Status.Success.getCode()) {

System.out.println(stateResponse.getMessage());

}

/**

* 集合是否存在

* @return

@Override

public Boolean hasCollect(String collectionName){

R hasResult = milvusServiceClient.hasCollection(

HasCollectionParam.newBuilder()

.withCollectionName(collectionName)

.build());

if (hasResult.getStatus() == R.Status.Success.getCode()) {

return hasResult.getData();

}

return false;

}

/**

* 向量库中插入数据

@Override

public Boolean insert(String name, List textIds, List> vectorList){

log.info("milvus insert name:{}, textIds:{}, vectorList:{}", name, textIds, vectorList);

List tagList = new ArrayList<>();

for (Long textId : textIds) {

tagList.add(0L);

}

List fieldsInsert = new ArrayList<>();

fieldsInsert.add(new InsertParam.Field(TEXTID, textIds)); // 文本对应的ids数据list

fieldsInsert.add(new InsertParam.Field(VECTOR, vectorList)); // 转换后的向量数据list

fieldsInsert.add(new InsertParam.Field(TAG, tagList)); // 标签占位符给个0

InsertParam param = InsertParam.newBuilder()

.withCollectionName(name)

.withFields(fieldsInsert)

.build();

R response = milvusServiceClient.insert(param);

if (response.getStatus() != R.Status.Success.getCode()) {

log.info("milvus insert vector fail! message:{}", response.getMessage());

return false;

}else{

return true;

}

/**

* 删除集合

* @param collectionName

@Override

public void dropCollect(String collectionName){

milvusServiceClient.dropCollection(

DropCollectionParam.newBuilder()

.withCollectionName(collectionName)

.build()

);

}

/**

* 根据ids删除向量

* @param collectionName

* @param indexIds

@Override

public void dropVectors(String collectionName, List indexIds){

String expr = TEXTID + " in " + indexIds;

DeleteParam param = DeleteParam.newBuilder()

.withCollectionName(collectionName)

.withExpr(expr)

.build();

R response = milvusServiceClient.delete(param);

if (response.getStatus() != R.Status.Success.getCode()) {

System.out.println(response.getMessage());

}

/**

* 向量搜索 - 向量库中用具体向量搜索 - 返回indexIds

@Override

public List search(String collectionName, int topK , List> vectorList){

// 构建查询条件进行向量字段查询待测试1024维度向量

SearchParam searchParam = io.milvus.param.dml.SearchParam.newBuilder()

.withCollectionName(collectionName)

.withVectorFieldName(VECTOR)

.withOutFields(Lists.newArrayList("*"))

.withVectors(vectorList)

.withTopK(topK)

.build();

R searchResults = milvusServiceClient.search(searchParam);

if (searchResults.getStatus() != R.Status.Success.getCode()) {

log.info(searchResults.getMessage());

}

List textIdList = new ArrayList<>() ;

SearchResultsWrapper wrapper = new SearchResultsWrapper(searchResults.getData().getResults());

for (int i = 0; i < vectorList.size(); ++i) {

List scores = wrapper.getIDScore(i);

for (SearchResultsWrapper.IDScore score:scores) {

Map filedsMap = score.getFieldValues();

textIdList.add(Long.valueOf(String.valueOf(filedsMap.get(TEXTID))));

}

return textIdList;

}

/**

* 删除集合中的 id对应的向量

public void deleteEmbedingById(){

List ids = Lists.newArrayList("441966745769900131","441966745769900133");

DeleteIdsParam param = DeleteIdsParam.newBuilder()

.withCollectionName(FaceArchive.COLLECTION_NAME_MILVUS_TESTONE)

.withPrimaryIds(ids)

.build();

R response = milvusServiceClient.delete(param);

if (response.getStatus() != R.Status.Success.getCode()) {

System.out.println(response.getMessage());

}

for (Object deleteId : response.getData().getDeleteIds()) {

System.out.println(deleteId);

}

// 测试用的向量数据类型

public List> getListVector(){

List vectorData = new ArrayList<>();

for (int i = 0; i < 1; i++) {

vectorData.add((float) Math.random());

}

List> vectors = new ArrayList<>();

vectors.add(vectorData);

return vectors;

}

以上，跟业务进行结合直接调用操作向量库的API接口即可~

PS：milvus 集成在springboot项目中踩的坑：

#首先就是milvus和protobuf的版本要对应上可以查下官网api提供的服务端的milvus版本对应的java sdk milvus版本然后根据milvus sdk版本再找到对应的protobuf版本

#其次根据官网文档api创建完集合后是无法自动加载集合的需要手动为集合创建一个索引比如IVF类型的索引再进行集合加载到内存然后才可以对该集合查询插入数据等操作

插入过程中：所有字段值都不能为空且所有字段值条数都需一样也就是统一字段条数一致！！

#还有就是，创建集合时候确定好向量字段的维度，

后面插入向量数据以及查询向量数据的数据维度要与创建向量字段的维度相同！！

注意！ milvus向量库只负责向量的操作存储及查询这些，并不负责文本or视频音频转为向量数据的过程，此过程需要专门模型转换进行数据处理为向量数据才可用milvus向量数据库操作！

好文链接

评论可见，请评论后查看内容，谢谢！！！评论后请刷新页面。

夸智网

笔记数据库 spring boot Springboot整合Milvus向量库

容器【Docker常用命令（四）】

学习 python Transformer模型-用jupyter演示逐步计算attention

发表评论取消回复

夸智网

笔记 数据库 spring boot Springboot整合Milvus向量库

容器 【Docker常用命令（四）】

学习 python Transformer模型-用jupyter演示逐步计算attention

相关文章

发表评论取消回复

笔记数据库 spring boot Springboot整合Milvus向量库

容器【Docker常用命令（四）】