Milvus 实战：从安装部署到百万级向量检索的全流程 Java 代码示例

最新推荐文章于 2025-12-19 18:32:28 发布
原创 最新推荐文章于 2025-12-19 18:32:28 发布 · 570 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#milvus #java #eureka

一、Milvus 安装部署（Docker Compose）

1. 环境准备

  • Docker 版本 ≥ 20.10.0
  • Docker Compose 版本 ≥ 2.0.0

2. 部署步骤

# 1. 下载 Milvus 配置文件
wget https://github.com/milvus-io/milvus/releases/download/v2.3.5/milvus-standalone-docker-compose.yml -O docker-compose.yml

# 2. 启动 Milvus 服务
docker-compose up -d

# 3. 验证服务状态
docker-compose ps
# 预期输出：milvus-standalone 状态为 Up

3. 停止服务（可选）

docker-compose down

二、Java 客户端配置

1. 依赖引入（Maven）

在 pom.xml 中添加以下依赖：

<dependencies>
    <!-- Milvus Java SDK -->
    <dependency>
        <groupId>io.milvus</groupId>
        <artifactId>milvus-sdk-java</artifactId>
        <version>2.3.5</version>
    </dependency>
    <!-- 用于生成随机向量 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-math3</artifactId>
        <version>3.6.1</version>
    </dependency>
    <!-- 日志框架 -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.36</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.11</version>
    </dependency>
</dependencies>

2. 核心配置类

import io.milvus.client.MilvusServiceClient;
import io.milvus.param.ConnectParam;

public class MilvusConfig {
    // Milvus 服务地址（默认端口 19530）
    private static final String HOST = "localhost";
    private static final int PORT = 19530;

    // 单例模式创建 Milvus 客户端
    private static MilvusServiceClient client;

    public static MilvusServiceClient getClient() {
        if (client == null) {
            ConnectParam connectParam = ConnectParam.newBuilder()
                    .withHost(HOST)
                    .withPort(PORT)
                    .build();
            client = new MilvusServiceClient(connectParam);
        }
        return client;
    }

    // 关闭客户端
    public static void closeClient() {
        if (client != null) {
            client.close();
            client = null;
        }
    }
}

三、核心功能实现

1. 集合管理（Collection）

创建集合
import io.milvus.param.*;
import io.milvus.param.collection.*;

public class CollectionManager {
    private final MilvusServiceClient client;

    public CollectionManager(MilvusServiceClient client) {
        this.client = client;
    }

    // 创建集合
    public void createCollection(String collectionName, int dimension) {
        // 定义字段
        FieldType idField = FieldType.newBuilder()
                .withName("id")
                .withDataType(DataType.Int64)
                .withPrimaryKey(true)
                .withAutoID(true) // 自动生成 ID
                .build();

        FieldType vectorField = FieldType.newBuilder()
                .withName("vector")
                .withDataType(DataType.FloatVector)
                .withDimension(dimension) // 向量维度
                .build();

        FieldType textField = FieldType.newBuilder()
                .withName("text")
                .withDataType(DataType.VarChar)
                .withMaxLength(512)
                .build();

        CreateCollectionParam createParam = CreateCollectionParam.newBuilder()
                .withCollectionName(collectionName)
                .withDescription("Java Milvus Demo Collection")
                .addFieldType(idField)
                .addFieldType(vectorField)
                .addFieldType(textField)
                .withEnableDynamicField(true) // 启用动态字段
                .build();

        R<RpcStatus> response = client.createCollection(createParam);
        if (response.getStatus() != R.Status.Success.getCode()) {
            throw new RuntimeException("Create collection failed: " + response.getMessage());
        }
        System.out.println("Collection created successfully!");
    }

    // 检查集合是否存在
    public boolean hasCollection(String collectionName) {
        HasCollectionParam param = HasCollectionParam.newBuilder()
                .withCollectionName(collectionName)
                .build();
        R<Boolean> response = client.hasCollection(param);
        return response.getData();
    }

    // 删除集合
    public void dropCollection(String collectionName) {
        DropCollectionParam param = DropCollectionParam.newBuilder()
                .withCollectionName(collectionName)
                .build();
        client.dropCollection(param);
        System.out.println("Collection dropped successfully!");
    }
}

2. 数据生成与插入

向量数据生成工具
import org.apache.commons.math3.random.RandomDataGenerator;

import java.util.ArrayList;
import java.util.List;

public class VectorGenerator {
    // 生成随机浮点向量
    public static List<List<Float>> generateRandomVectors(int count, int dimension) {
        List<List<Float>> vectors = new ArrayList<>(count);
        RandomDataGenerator random = new RandomDataGenerator();

        for (int i = 0; i < count; i++) {
            List<Float> vector = new ArrayList<>(dimension);
            for (int j = 0; j < dimension; j++) {
                vector.add((float) random.nextUniform(-1.0, 1.0));
            }
            vectors.add(vector);
        }
        return vectors;
    }

    // 生成测试文本数据
    public static List<String> generateTestTexts(int count) {
        List<String> texts = new ArrayList<>(count);
        for (int i = 0; i < count; i++) {
            texts.add("Test text " + i);
        }
        return texts;
    }
}
批量插入数据
import io.milvus.param.*;
import io.milvus.param.insert.*;
import io.milvus.response.*;

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class DataInsertor {
    private final MilvusServiceClient client;

    public DataInsertor(MilvusServiceClient client) {
        this.client = client;
    }

    // 批量插入数据
    public long insertBatch(String collectionName, List<List<Float>> vectors, List<String> texts) {
        InsertParam insertParam = InsertParam.newBuilder()
                .withCollectionName(collectionName)
                .withFields(List.of(
                        InsertParam.Field.newBuilder()
                                .withName("vector")
                                .withValues(vectors)
                                .build(),
                        InsertParam.Field.newBuilder()
                                .withName("text")
                                .withValues(texts)
                                .build()
                ))
                .build();

        R<MutationResult> response = client.insert(insertParam);
        if (response.getStatus() != R.Status.Success.getCode()) {
            throw new RuntimeException("Insert failed: " + response.getMessage());
        }
        return response.getData().getInsertCount();
    }

    // 百万级数据批量插入（多线程）
    public void insertMillionData(String collectionName, int dimension, int totalCount) {
        final int batchSize = 10000; // 每批次插入 10,000 条
        final int threadCount = 4;   // 4 线程并行插入

        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        long startTime = System.currentTimeMillis();

        for (int i = 0; i < totalCount; i += batchSize) {
            final int currentBatch = Math.min(batchSize, totalCount - i);
            executor.submit(() -> {
                List<List<Float>> vectors = VectorGenerator.generateRandomVectors(currentBatch, dimension);
                List<String> texts = VectorGenerator.generateTestTexts(currentBatch);
                insertBatch(collectionName, vectors, texts);
            });
        }

        executor.shutdown();
        try {
            executor.awaitTermination(1, TimeUnit.HOURS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        long endTime = System.currentTimeMillis();
        System.out.printf("Inserted %d vectors in %.2f seconds%n", 
                totalCount, (endTime - startTime) / 1000.0);
    }
}

3. 索引创建与加载

索引管理
import io.milvus.param.*;
import io.milvus.param.index.*;

public class IndexManager {
    private final MilvusServiceClient client;

    public IndexManager(MilvusServiceClient client) {
        this.client = client;
    }

    // 创建 IVF_FLAT 索引（适用于中小规模数据）
    public void createIVFFlatIndex(String collectionName, int nlist) {
        IndexParam indexParam = IndexParam.newBuilder()
                .withCollectionName(collectionName)
                .withFieldName("vector")
                .withIndexName("vector_index")
                .withIndexType(IndexType.IVF_FLAT)
                .withMetricType(MetricType.L2) // 欧氏距离
                .withExtraParam("{\"nlist\": " + nlist + "}")
                .build();

        R<RpcStatus> response = client.createIndex(indexParam);
        if (response.getStatus() != R.Status.Success.getCode()) {
            throw new RuntimeException("Create index failed: " + response.getMessage());
        }
        System.out.println("IVF_FLAT index created successfully!");
    }

    // 创建 HNSW 索引（适用于大规模数据，检索更快）
    public void createHNSWIndex(String collectionName, int M, int efConstruction) {
        IndexParam indexParam = IndexParam.newBuilder()
                .withCollectionName(collectionName)
                .withFieldName("vector")
                .withIndexName("vector_index")
                .withIndexType(IndexType.HNSW)
                .withMetricType(MetricType.L2)
                .withExtraParam("{\"M\": " + M + ", \"efConstruction\": " + efConstruction + "}")
                .build();

        R<RpcStatus> response = client.createIndex(indexParam);
        if (response.getStatus() != R.Status.Success.getCode()) {
            throw new RuntimeException("Create index failed: " + response.getMessage());
        }
        System.out.println("HNSW index created successfully!");
    }

    // 加载集合到内存
    public void loadCollection(String collectionName) {
        LoadCollectionParam loadParam = LoadCollectionParam.newBuilder()
                .withCollectionName(collectionName)
                .build();

        R<RpcStatus> response = client.loadCollection(loadParam);
        if (response.getStatus() != R.Status.Success.getCode()) {
            throw new RuntimeException("Load collection failed: " + response.getMessage());
        }
        System.out.println("Collection loaded to memory!");
    }

    // 释放集合内存
    public void releaseCollection(String collectionName) {
        ReleaseCollectionParam releaseParam = ReleaseCollectionParam.newBuilder()
                .withCollectionName(collectionName)
                .build();
        client.releaseCollection(releaseParam);
        System.out.println("Collection released from memory!");
    }
}

4. 向量检索

检索实现
import io.milvus.param.*;
import io.milvus.param.search.*;
import io.milvus.response.*;

import java.util.List;

public class VectorSearcher {
    private final MilvusServiceClient client;

    public VectorSearcher(MilvusServiceClient client) {
        this.client = client;
    }

    // 向量检索
    public void searchVectors(String collectionName, List<Float> queryVector, int topK) {
        // 构建检索参数
        SearchParam searchParam = SearchParam.newBuilder()
                .withCollectionName(collectionName)
                .withMetricType(MetricType.L2)
                .withOutFields(List.of("id", "text")) // 返回字段
                .withTopK(topK)
                .withVectors(List.of(queryVector))
                .withVectorFieldName("vector")
                .withParams("{\"nprobe\": 10}") // IVF 索引参数：检索的聚类中心数量
                // .withParams("{\"ef\": 64}") // HNSW 索引参数：检索时的 ef 值
                .build();

        long startTime = System.currentTimeMillis();
        R<SearchResults> response = client.search(searchParam);
        long endTime = System.currentTimeMillis();

        if (response.getStatus() != R.Status.Success.getCode()) {
            throw new RuntimeException("Search failed: " + response.getMessage());
        }

        // 处理检索结果
        SearchResultsData resultsData = response.getData().getResults();
        System.out.printf("Search completed in %.2f ms%n", (endTime - startTime) / 1.0);
        System.out.printf("Found %d results for top %d%n", resultsData.getRowCount(), topK);

        // 输出结果
        for (int i = 0; i < resultsData.getRowCount(); i++) {
            SearchResultsData.RowRecord row = resultsData.getRowRecord(i);
            long id = row.getLong("id");
            String text = row.getString("text");
            float distance = row.getFloat("distance");
            System.out.printf("Rank %d: ID=%d, Text=%s, Distance=%.6f%n", 
                    i + 1, id, text, distance);
        }
    }

    // 批量检索（多查询向量）
    public void batchSearch(String collectionName, List<List<Float>> queryVectors, int topK) {
        SearchParam searchParam = SearchParam.newBuilder()
                .withCollectionName(collectionName)
                .withMetricType(MetricType.L2)
                .withOutFields(List.of("id", "text"))
                .withTopK(topK)
                .withVectors(queryVectors)
                .withVectorFieldName("vector")
                .withParams("{\"nprobe\": 10}")
                .build();

        long startTime = System.currentTimeMillis();
        R<SearchResults> response = client.search(searchParam);
        long endTime = System.currentTimeMillis();

        System.out.printf("Batch search completed in %.2f ms%n", (endTime - startTime) / 1.0);
        System.out.printf("Total queries: %d%n", queryVectors.size());
    }
}

四、百万级向量检索完整示例

1. 主程序入口

public class MilvusJavaDemo {
    private static final String COLLECTION_NAME = "java_demo_collection";
    private static final int DIMENSION = 128; // 向量维度
    private static final int TOTAL_COUNT = 1000000; // 百万级数据

    public static void main(String[] args) {
        MilvusServiceClient client = MilvusConfig.getClient();
        try {
            // 1. 集合管理
            CollectionManager collectionManager = new CollectionManager(client);
            if (collectionManager.hasCollection(COLLECTION_NAME)) {
                collectionManager.dropCollection(COLLECTION_NAME);
            }
            collectionManager.createCollection(COLLECTION_NAME, DIMENSION);

            // 2. 插入百万级数据
            DataInsertor dataInsertor = new DataInsertor(client);
            System.out.println("Start inserting " + TOTAL_COUNT + " vectors...");
            dataInsertor.insertMillionData(COLLECTION_NAME, DIMENSION, TOTAL_COUNT);

            // 3. 创建索引
            IndexManager indexManager = new IndexManager(client);
            // 选择索引类型：IVF_FLAT 或 HNSW
            indexManager.createIVFFlatIndex(COLLECTION_NAME, 1024); // nlist=1024
            // indexManager.createHNSWIndex(COLLECTION_NAME, 16, 256); // M=16, efConstruction=256

            // 4. 加载集合到内存
            indexManager.loadCollection(COLLECTION_NAME);

            // 5. 向量检索
            VectorSearcher searcher = new VectorSearcher(client);
            // 生成查询向量
            List<Float> queryVector = VectorGenerator.generateRandomVectors(1, DIMENSION).get(0);
            System.out.println("\nStart searching...");
            searcher.searchVectors(COLLECTION_NAME, queryVector, 10);

            // 6. 批量检索测试
            System.out.println("\nStart batch search...");
            List<List<Float>> batchQueryVectors = VectorGenerator.generateRandomVectors(100, DIMENSION);
            searcher.batchSearch(COLLECTION_NAME, batchQueryVectors, 10);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            MilvusConfig.closeClient();
        }
    }
}

2. 运行结果示例

Collection created successfully!
Start inserting 1000000 vectors...
Inserted 1000000 vectors in 45.23 seconds
IVF_FLAT index created successfully!
Collection loaded to memory!

Start searching...
Search completed in 12.56 ms
Found 10 results for top 10
Rank 1: ID=123456, Text=Test text 123456, Distance=0.001234
Rank 2: ID=789012, Text=Test text 789012, Distance=0.002345
...

Start batch search...
Batch search completed in 89.32 ms
Total queries: 100

五、性能优化建议

  1. 插入优化

    • 批次大小：建议 10,000-50,000 条 / 批次
    • 多线程并行插入：充分利用 CPU 资源
    • 关闭自动刷新：插入完成后手动调用 flush 方法

  2. 索引优化

    • IVF_FLAT：nlist 建议设置为 sqrt (数据量)，如百万级数据设置为 1024
    • HNSW：M=16-64，efConstruction=200-500（值越大索引质量越高，但构建时间越长）
    • 检索时调整 nprobe（IVF）或 ef（HNSW）参数平衡速度与精度

  3. 检索优化

    • 批量检索：减少网络往返次数
    • 只返回必要字段：降低数据传输开销
    • 使用连接池：复用客户端连接

六、常见问题与解决方案

问题解决方案
连接超时检查 Milvus 服务是否正常运行，网络是否通畅
内存不足调整 JVM 堆内存大小，或减少批次插入量
索引构建失败检查索引参数是否合法，确保数据已插入
检索结果为空确认集合已加载到内存，查询向量维度匹配

七、扩展功能

  1. 分区管理：针对大规模数据，可按时间或业务维度创建分区
  2. 数据更新 / 删除：支持根据主键更新或删除数据
  3. 混合检索：结合向量检索与标量过滤（如 text LIKE '%keyword%'）
  4. 分布式部署：Milvus 支持集群部署，提高可用性与扩展性

八、总结

本示例完整演示了 Milvus 从安装部署到百万级向量检索的全流程，涵盖了集合管理、数据插入、索引创建、向量检索等核心功能。通过 Java SDK，开发者可以轻松集成 Milvus 到自己的应用中，实现高效的向量检索服务。

建议根据实际业务场景调整向量维度、索引类型、检索参数等，以达到最佳的性能表现。

参考资料：

语义检索系统【三】：基于Milvus 搭建召回系统抽取向量进行检索，加速索引
丨汀、的博客
08-02 2056
语义检索系统【三】：基于Milvus 搭建召回系统抽取向量进行检索，加速索引
【大数据】从0到1上手Milvus：向量数据库的实战秘籍
大雨的博客
07-21 718
在技术创新方面，Milvus 可能会进一步优化索引算法和搜索性能，以应对不断增长的数据规模和复杂的查询需求 。例如，随着数据量的不断增加，现有的索引算法可能需要不断改进，以提高搜索效率和准确性 。同时，Milvus 可能会加强对多模态数据的支持，如将文本、图像、音频等多种类型的数据融合在一起进行存储和检索，这将为智能安防、智能医疗等领域带来更多创新应用 。在智能安防中，可以将监控视频中的图像数据和对应的文本描述数据同时存储在 Milvus 中，通过多模态检索快速定位相关的监控信息 。
打造AI应用基础设施：Milvus向量数据库部署与运维
专注分享编程开发与技术进阶干货！
04-14 2247
Milvus是一款高性能、可扩展的开源向量数据库，专为AI应用中的相似性搜索而设计。本文全面介绍Milvus的核心特性，详细对比Milvus Lite、Standalone和Distributed三种部署模式的优缺点与适用场景。通过实操命令演示各种部署方法，并深入讲解数据管理、向量搜索等基本使用技巧，以及基于Prometheus的监控、备份恢复等运维实践。
零基础学AI大模型之Milvus实战：Attu可视化安装+Python整合全案例
chandfy的博客
12-01 1234
本文介绍了AI大模型实战系列文章，重点分享Milvus向量数据库的Attu可视化工具安装与Python整合案例。Attu作为官方开源的图形化管理工具，提供跨平台支持、数据库全生命周期管理、向量检索等核心功能。文章详细讲解Attu的安装部署流程（包括Docker方式），并给出Python代码示例展示集合创建、数据插入和相似度查询的完整操作链路。该教程适合零基础开发者快速掌握Milvus的实战应用，降低学习门槛。
Milvus 2.4 使用详解：从零构建向量数据库并实现搜索功能（Python 实战）
weixin_38252409的博客
05-12 2008
在大规模向量数据检索场景中，Milvus 是一个非常强大的开源向量数据库。它支持高效的相似性搜索、灵活的数据模型设计以及多语言接口。本文将通过 Python 客户端 `pymilvus`，带你一步步从零开始使用 Milvus 构建一个简单的向量数据库，并实现插入数据与相似性搜索的完整流程。
干货收藏：Milvus向量数据库实操指南，手把手搭建企业级智能文档检索系统
m0_48891301的博客
10-08 1755
干货收藏：Milvus向量数据库实操指南，手把手搭建企业级智能文档检索系统
【RAG落地利器】向量数据库Milvus教程：如何实现MetaData检索过滤
python1234_的博客
01-22 1290
此命令允许您使用主机网络运行 docker 容器，并为服务器指定要侦听的自定义端口。
从单模态到多模态：Milvus混合搜索如何解决AI检索的精度难题
gitblog_00139的博客
10-01 956
你是否遇到过这样的困境：基于语义的向量搜索总是漏掉关键词，而传统的关键词检索又无法理解上下文？Milvus混合搜索功能通过融合密集向量（Dense Vector）与稀疏向量（Sparse Vector）的优势，正在重新定义AI时代的信息检索范式。本文将带你从零开始掌握这一技术，读完后你将能够： - 理解密集向量与稀疏向量的底层差异 - 构建支持混合搜索的Milvus集合 - 实现语义+关键词的协...
从零开始掌握 Milvus Java SDK：构建智能向量检索应用
gitblog_00935的博客
11-19 657
Milvus Java SDK 是连接 Java 应用与 Milvus 向量数据库的强大桥梁，让开发者能够轻松构建高效的向量检索系统。无论你是想要实现图像相似度搜索、智能推荐引擎，还是语义理解应用，这个工具都能为你提供专业级的支持。 ## 🎯 为什么选择 Milvus Java SDK？ 在当今数据驱动的时代，向量检索已成为许多智能应用的核心技术。Milvus Java SDK 让你能够：
【自然语言处理】基于Java+Vue的向量数据库语义检索与相似文档查重系统设计： 项目介绍 基于java+vue的向量数据库的语义检索与相似文档查重系统设计与实现（含模型描述及部分示例代码）
12-17
项目涵盖从文档预处理、向量化建模、向量存储与相似度检索，到前后端交互展示的完整流程，支持多格式文档解析、分段查重、结果高亮显示等功能，并强调数据安全、系统扩展性及多场景应用能力。文中还提供了关键模块的...
【揭秘Springboot与Milvus】：打造企业级向量检索服务的11个实战技巧
[【揭秘Springboot与Milvus】：打造企业级向量检索服务的11个实战技巧](https://springframework.guru/wp-content/uploads/2015/08/Screen-Shot-2015-08-13-at-7.29.35-AM-1024x573.png) # 摘要 本文介绍了如何在...
向量数据库选型实战指南：Milvus架构深度解析与技术对比
猫步轻移，以学求知。余于此方寸之地，如猫观鼠，细察技艺所得，思维所悟。灵思如猫之警觉，日积月累，终成智海；
05-25 1732
随着大语言模型和AI应用的快速普及，传统数据库在处理高维向量数据时面临的性能瓶颈日益凸显。当文档经过嵌入模型处理生成768到1536维的向量后，传统B-Tree索引的检索效率会出现显著下降，而现代应用对毫秒级响应的严苛要求使得这一技术挑战变得更加紧迫。 本文将系统性地为技术团队提供向量数据库的全方位选型指南。从技术原理的深度剖析到主流产品的客观对比，从Milvus、Pinecone、Qdrant等热门解决方案的优劣分析到具体的部署架构建议，文章涵盖了从概念验证到生产环境的完整技术路径。
Milvus IllegalAccessError:com.google.protobuf.LazyStringArrayList.emptyList()
最新发布
IT_Octopus的博客
12-19 91
milvus-sdk-java和 protobuf-java 版本冲突问题，AI 确实给你了明确的问题出现的原因，但是让你切换的版本是错的，不要过度依赖AI，这是我依旧坚持写博客的原因，所见即所得。之前的版本是3.21.7 导致的报错，Milvus 内部调用了 LazyStringArrayList.emptyList() 方法。但是3.21.7没有，所以改成3.24.0 修复。maven 树如下(Milvus -JAVA的依赖很混乱，大家要格外注意)
Milvus向量数据库：AI时代的向量搜索利器
AI开发者
12-16 1131
Milvus 是一款专为存储和管理大规模嵌入向量设计的开源数据库，旨在处理由机器学习模型生成的非结构化数据（如图像、文本等）。它支持万亿级向量索引，核心功能是通过计算向量间的相似度（如欧氏距离、余弦相似度）来分析数据相关性。
阿里云 Milvus 轻松实现文搜图&图搜图
csdn565973850的博客
12-17 934
本方案基于阿里云向量检索服务 Milvus 版，结合阿里云百炼模型服务的多模态语义理解能力，构建高效、灵活的搜索系统，轻松支持文搜图、图搜图、跨模态检索等典型应用。通过 Serverless AI 应用开发平台 Function AI 部署至函数计算，可将模型服务一键部署至函数计算，实现快速上线、自动扩缩容与全托管运维，显著降低部署与运营成本，助力企业聚焦核心业务创新。
java调用milvus数据库
m0_73037076的博客
12-19 365
java操作milvus 向量数据库 crud
Milvus 向量数据库的发展历程：从开源项目到全球 AI 基础设施的演进之路
reset2021的博客
12-18 53
摘要：本文系统梳理了开源向量数据库Milvus从2019年诞生至今的技术演进历程。作为专为AI应用设计的向量数据库，Milvus经历了从实验室原型到全球超3000家企业采用的跨越式发展。文章详细分析了其架构从单机版到云原生微服务的重大变革，功能从基础相似性搜索到支持RAG、多模态检索等复杂场景的持续扩展，以及生态从单一数据库到完整工具链的完善过程。同时探讨了Milvus在AIGC时代的技术战略和未来发展方向，展现了其如何成长为AI基础设施领域的关键组件。
Milvus 混合检索：构建下一代 RAG 与多模态应用的核心引擎
reset2021的博客
12-18 151
摘要：随着大语言模型和生成式AI的快速发展，检索增强生成（RAG）成为主流架构。传统单一向量检索在语义覆盖和关键词匹配方面存在局限。Milvus v2.3引入混合检索技术，结合稀疏向量与密集向量的优势，显著提升检索性能。本文详解Milvus混合检索的技术原理、应用场景及实现方法，并以BGE-M3模型为例演示如何构建高性能混合检索系统，为RAG和多模态AI提供更强大的检索能力。
Milvus 向量数据库部署方案全景指南：从单机开发到生产级高可用集群
reset2021的博客
12-18 53
本文系统介绍了Milvus向量数据库的四大部署方案：嵌入式开发利器Milvus Lite、单机简易部署Standalone模式、生产级高可用Cluster模式以及全托管SaaS服务Zilliz Cloud。针对不同应用场景（开发测试、小型应用、大规模生产环境），详细分析了各模式的适用条件、资源配置要求和部署步骤，并提供了关键配置示例。文章强调正确选择部署方案对系统性能至关重要，帮助开发者根据向量规模、QPS和高可用需求，选择最优部署方式，实现资源优化与稳定运行。
本地向量数据库搭建与优化实战指南
压缩包中的项目文件“CnPtZlbXPz6FG4FKBP3F-master-b5b8066093e9ef2e63410c987085823039d24e34”很可能包含了上述流程的完整代码示例，包括数据预处理脚本、向量编码模型调用、Milvus连接配置、索引创建语句、查询...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

canjun_wen

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值