Milvus概念
非结构化数据、嵌入和 Milvus
非结构化数据（如文本、图像、音频）格式多样，蕴含丰富的语义信息，使其分析变得复杂。为了管理这种复杂性，嵌入技术被用来将非结构化数据转换为数值向量，这些向量能够捕捉数据的核心特征。这些向量随后被存储在向量数据库中，支持快速和可扩展的搜索与分析。
Milvus 提供强大的数据建模能力，使您能够将非结构化或多模态数据组织成结构化的集合。它支持多种数据类型，用于不同的属性建模，包括常见的数值和字符类型、各种向量类型、数组、集合和 JSON，避免了维护多个数据库系统的麻烦。
Milvus 的部署模式
Milvus 提供三种部署模式，涵盖从本地原型开发到大规模 Kubernetes 集群管理数十亿向量的数据规模：
- Milvus Lite
- 简介：Milvus Lite 是一个 Python 库，能够轻松集成到您的应用程序中。作为 Milvus 的轻量级版本，适合在 Jupyter Notebook 中进行快速原型开发或在资源有限的边缘设备上运行。
- 适用场景：快速开发、边缘计算。
- 学习资源： Milvus Lite 文档
- Milvus Standalone
- 简介：Milvus Standalone 是一个单机服务器部署，所有组件捆绑在一个 Docker 镜像中，便于部署和管理。
- 适用场景：开发测试、小规模部署。
- 学习资源： Milvus Standalone 部署指南
- Milvus Distributed
- 简介：Milvus Distributed 可部署在 Kubernetes 集群上，具备云原生架构，专为十亿级或更大规模的应用场景设计。该架构确保关键组件的冗余性和高可用性。
- 适用场景：大规模生产环境、高可用性需求。
- 学习资源： Milvus Distributed 部署指南
Milvus 的性能优势
Milvus 从设计之初就注重高效性，使其在大多数情况下比其他向量数据库快 2-5 倍（参考 VectorDBBench 结果）。这种高性能来源于以下几个关键设计决策：
- 硬件感知优化
- 目的：适应各种硬件环境，充分利用硬件性能。
- 实现方式：针对多种硬件架构和平台（如 AVX512、SIMD、GPU 和 NVMe SSD）进行了性能优化。
- 先进的搜索算法
- 支持多种索引/搜索算法：包括 IVF、HNSW、DiskANN 等，所有这些算法都经过深度优化。
- 性能比较：与流行的实现（如 FAISS 和 HNSWLib）相比，Milvus 提供 30%-70% 更好的性能。
- C++ 搜索引擎
- 理由：向量数据库的性能 80% 由搜索引擎决定。
- 优势：C++ 的高性能、低级优化和高效的资源管理。
- 优化方式：集成了大量硬件感知代码优化，包括汇编级向量化、多线程并行化和调度，充分利用硬件能力。
- 列式存储
- 优势
- 数据访问模式：查询时仅读取涉及的特定字段，减少数据访问量。
- 向量化操作：对列式数据的操作可以轻松向量化，提升性能。
- 优势
Milvus 支持的搜索类型
Milvus 支持多种搜索功能，以满足不同用例的需求：
- ANN 搜索（Approximate Nearest Neighbor Search）
- 功能：查找与查询向量最接近的前 K 个向量。
- 过滤搜索（Filtering Search）
- 功能：在指定的过滤条件下执行 ANN 搜索。
- 范围搜索（Range Search）
- 功能：查找在指定半径范围内的向量。
- 混合搜索（Hybrid Search）
- 功能：基于多个向量字段执行 ANN 搜索。
- 关键词搜索（Keyword Search）
- 功能：基于 BM25 算法的关键词搜索。
- 重新排序（Reranking）
- 功能：根据附加条件或二次算法调整搜索结果的顺序，精炼初始的 ANN 搜索结果。
- 获取（Fetch）
- 功能：通过主键检索数据。
- 查询（Query）
- 功能：使用特定表达式检索数据。
综合功能集： 除了上述关键搜索功能，Milvus 还提供了一系列围绕 ANN 搜索实现的功能，充分利用其能力。
Milvus 的 API 和 SDK
Milvus 提供多种 API 和 SDK，支持不同编程语言，方便开发者集成到各种应用中：
- RESTful API（官方提供）
- PyMilvus（Python SDK，官方提供）
- Go SDK（官方提供）
- Java SDK（官方提供）
- Node.js（JavaScript）SDK（官方提供）
- C# SDK（由 Microsoft 贡献）
这些 API 和 SDK 使得 Milvus 能够轻松集成到各种开发环境和应用程序中，支持多种编程语言的开发者快速上手。
Milvus 的高级数据类型
除了基本的原始数据类型，Milvus 还支持各种高级数据类型及其适用的距离度量：
- 稀疏向量（Sparse Vectors）
- 二进制向量（Binary Vectors）
- JSON 支持
- 数组支持
距离度量： Milvus 支持多种距离度量方法，如 L2 距离、余弦相似度、内积等，以适应不同类型的数据和搜索需求。
Milvus 支持的搜索算法
Milvus 支持一系列可调节的索引和搜索算法，以满足不同应用场景的需求：
- 内存中的索引（In-memory Index）
- 磁盘上的索引（On-disk Index）
- GPU 索引（GPU Index）
详细信息请参阅 Milvus 的官方文档中的 In-memory Index、On-disk Index 和 GPU Index 部分。
分区和分区键
分区（Partitions） 是 Milvus 集合的子划分。通过选择一个标量字段作为分区键，可以提升搜索性能。
管理分区：
- 创建分区：根据业务需求划分数据。
- 使用分区键：在搜索时利用分区键加速查询。
详细信息请参阅 Manage Partitions 和 Use Partition Key 部分。
可调节的一致性模型
一致性（Consistency） 确保在写入或读取数据时，每个 Milvus 节点或副本对数据的视图保持一致。您可以在进行 ANN 搜索时轻松调节一致性级别，以平衡数据一致性和查询性能。
详细信息请参阅 Consistency 部分。
高吞吐量的数据导入
为了高效地将大量数据导入 Milvus，而不是逐一插入，可以使用 Milvus 提供的高吞吐量数据导入工具。这些工具支持批量导入和高效的数据处理。
详细信息请参阅 Prepare Source Data 和 Import Data 部分。
多租户支持
Milvus 实现了多租户场景下的多项功能，包括分区键、聚类键等，满足不同用户和应用的隔离和资源管理需求。
详细信息请参阅 Multi-tenancy Strategies 部分。
安全性与授权
Milvus 提供多种安全性配置和授权机制，确保数据的安全和系统的可靠性：
- 可调节的一致性模型
- 作用：确保数据一致性，防止数据冲突和不一致。
- 数据隔离和资源控制
- 作用：在多租户场景中实现数据隔离，防止数据泄露和滥用。
- 实现方式：通过管理资源组和聚类压实等功能，控制不同用户或租户的资源使用和数据访问。
详细信息请参阅 Manage Resource Groups 和 Clustering Compaction 部分。
AI 集成
Milvus 与多种 AI 工具和模型集成，支持从非结构化数据到向量嵌入的转换，以及搜索结果的优化：
- 嵌入模型集成（Embedding Model Integrations）
- 功能：将非结构化数据转换为数值嵌入，存储在 Milvus 中。
- 实现方式：PyMilvus（Python SDK）集成了多种嵌入模型，便于快速准备向量嵌入数据。
- 详细信息：请参阅 Embedding Overview。
- 重新排序模型集成（Reranking Model Integrations）
- 功能：在信息检索和生成式 AI 领域，重新排序模型优化初始搜索结果的顺序。
- 实现方式：PyMilvus 集成了多种重新排序模型，优化 ANN 搜索返回的结果顺序。
- 详细信息：请参阅 Rerankers Overview。
- LangChain 和其他 AI 工具集成
- 功能：在生成式 AI 时代，工具如 LangChain 关注应用开发，Milvus 通常作为这些工具的向量存储组件。
- 实现方式：通过集成 Milvus 到您喜欢的 AI 工具中，扩展其功能和性能。
- 详细信息：请参阅 Integrations and Tutorials。
工具和生态系统
Milvus 生态系统包含多种工具，帮助用户更高效地管理和使用 Milvus：
- Attu
- 简介：Attu 是一个集成的直观 GUI，帮助您管理 Milvus 及其存储的数据。
- 详细信息：请参阅 Attu 仓库。
- Birdwatcher
- 简介：Birdwatcher 是一个用于调试 Milvus 的工具。通过连接 etcd，您可以检查 Milvus 系统的状态或动态配置系统。
- 详细信息：请参阅 Birdwatcher 文档。
- Prometheus & Grafana 集成
- 功能：Prometheus 是一个开源系统监控和报警工具包，Grafana 是一个开源的可视化平台，可连接所有数据源。
- 用途：使用 Prometheus 和 Grafana 作为监控服务提供商，直观地监控 Milvus 分布式系统的性能。
- 详细信息：请参阅 Deploying Monitoring Services。
- Milvus Backup
- 功能：Milvus Backup 是一个允许用户备份和恢复 Milvus 数据的工具，提供 CLI 和 API 以适应不同的应用场景。
- 详细信息：请参阅 Milvus Backup 文档。
- Milvus Capture Data Change (CDC)
- 功能：Milvus-CDC 能够捕获和同步 Milvus 实例中的增量数据，确保业务数据的可靠性，通过在源和目标实例之间无缝转移数据，实现易于增量备份和灾难恢复。
- 详细信息：请参阅 Milvus CDC 文档。
- Milvus Connectors
- 功能：Milvus 提供了一系列连接器，帮助您无缝集成 Milvus 与第三方工具，如 Apache Spark。
- 用途：使用 Spark Connector 将 Milvus 数据馈送到 Apache Spark 进行机器学习处理。
- 详细信息：请参阅 Spark-Milvus Connector。
- Vector Transmission Services (VTS)
- 功能：Milvus 提供一组工具，用于在 Milvus 实例和多个数据源之间传输数据，包括 Zilliz 集群、Elasticsearch、Postgres (PgVector) 以及其他 Milvus 实例。
- 详细信息：请参阅 Migrations。
Milvus 系统配置检查表解析
文档提到 Milvus 维护了大量的配置参数，每个参数都有默认值，用户可以根据需求灵活修改这些参数，以优化系统性能和适应不同的应用场景。这些配置仅在 Milvus 启动时生效，以下是配置的各个部分及其详细说明：
配置分类
Milvus 将配置参数根据组件、依赖关系和一般使用情况分类为多个部分，便于维护和管理。以下是各个配置部分的详细解析：
1. etcd
用途：用于存储 Milvus 的元数据和服务发现信息。
关键参数：
etcd.endpoints：etcd 集群的地址列表。etcd.username和etcd.password：用于认证的用户名和密码。etcd.timeout：与 etcd 通信的超时时间。
示例：
etcd:
endpoints:
- "http://localhost:2379"
username: "etcd_user"
password: "etcd_password"
timeout: 5
说明：etcd 作为分布式键值存储系统，Milvus 使用它来管理元数据和服务发现。确保 etcd 配置正确，Milvus 才能正常连接和使用 etcd。
2. metastore
用途：配置 Milvus 的元数据存储方式，支持 TiKV 等存储引擎。
关键参数：
metastore.type：元数据存储类型，如tikv。metastore.tikv.address：TiKV 集群的地址。metastore.tikv.timeout：TiKV 通信的超时时间。
示例：
metastore:
type: "tikv"
tikv:
address: "127.0.0.1:2379"
timeout: 5
说明：metastore 负责存储 Milvus 的元数据。选择 TiKV 作为存储引擎时，需要配置 TiKV 的地址和通信参数。
3. tikv
用途：配置 TiKV 作为 Milvus 的元数据存储后端。
关键参数：
tikv.address：TiKV 集群的地址列表。tikv.security.enable：是否启用安全通信。tikv.security.tls.cert、tikv.security.tls.key、tikv.security.tls.ca_cert：TLS 证书相关路径。
示例：
tikv:
address:
- "127.0.0.1:2379"
security:
enable: true
tls:
cert: "/path/to/cert.pem"
key: "/path/to/key.pem"
ca_cert: "/path/to/ca_cert.pem"
说明：当启用 TiKV 作为 metastore 时，Milvus 仍然需要 etcd 进行服务发现。TiKV 适用于需要更好水平扩展性的元数据存储场景。
4. localStorage
用途：配置 Milvus 的本地存储选项。
关键参数：
localStorage.path：本地存储的数据路径。localStorage.max_size：本地存储的最大容量。
示例：
localStorage:
path: "/var/lib/milvus/data"
max_size: "100GB"
说明：localStorage 负责 Milvus 在本地文件系统中的数据存储。配置合适的存储路径和容量限制，有助于数据管理和性能优化。
5. minio
用途：配置与 MinIO/S3/GCS 或任何支持 S3 API 的服务的集成，负责 Milvus 的数据持久化存储。
关键参数：
minio.address：MinIO 服务的地址。minio.access_key和minio.secret_key：访问 MinIO 的凭证。minio.bucket_name：用于存储数据的桶名称。
示例：
minio:
address: "http://localhost:9000"
access_key: "minio_access_key"
secret_key: "minio_secret_key"
bucket_name: "milvus_data"
说明：Milvus 通过 S3 API 与 MinIO 等存储服务交互，确保数据的持久化和高可用性。配置正确的 MinIO 地址和凭证，确保数据存储的安全性和可靠性。
6. mq（消息队列）
用途：配置 Milvus 使用的消息队列类型及其参数。Milvus 支持四种消息队列（MQ）：Rocksmq、Natsmq、Pulsar 和 Kafka。
关键参数：
mq.type：选择使用的消息队列类型，如rocksmq、natsmq、pulsar、kafka。- 独立模式（Standalone/local）：Rocksmq（默认） > Natsmq > Pulsar > Kafka。
- 集群模式：Pulsar（默认） > Kafka（Rocksmq 和 Natsmq 不支持集群模式）。
示例：
mq:
type: "pulsar"
pulsar:
service_url: "pulsar://localhost:6650"
admin_url: "http://localhost:8080"
说明：根据系统规模和性能需求，选择合适的消息队列类型。Rocksmq 适用于独立模式，Pulsar 和 Kafka 适用于集群模式。
7. pulsar
用途：配置 Pulsar 作为 Milvus 的日志和消息传递系统。
关键参数：
pulsar.service_url：Pulsar 服务的 URL。pulsar.admin_url：Pulsar 管理 API 的 URL。pulsar.topic：用于日志的 Pulsar 主题名称。
示例：
pulsar:
service_url: "pulsar://localhost:6650"
admin_url: "http://localhost:8080"
topic: "milvus_logs"
说明：Pulsar 是一种分布式消息系统，Milvus 使用它来处理日志和消息传递，确保系统的可靠性和可扩展性。
8. rocksmq
用途：配置 Rocksmq 作为 Milvus 的消息队列系统。
关键参数：
rocksmq.path：Rocksmq 数据存储路径。rocksmq.timeout：Rocksmq 操作的超时时间。
示例：
rocksmq:
path: "/var/lib/milvus/rocksmq"
timeout: 5
说明：Rocksmq 基于 RocksDB，适用于独立模式下的消息队列需求。如果想启用 Kafka，需要注释掉 Pulsar 的相关配置。
9. kafka
用途：配置 Kafka 作为 Milvus 的消息队列系统。
关键参数：
kafka.brokerList：Kafka broker 的地址列表。kafka.saslUsername、kafka.saslPassword、kafka.saslMechanisms：用于 SASL 认证的凭证和机制。kafka.securityProtocol：Kafka 的安全协议类型。kafka.ssl.enabled：是否启用 SSL。kafka.ssl.tlsCert、kafka.ssl.tlsKey、kafka.ssl.tlsCaCert、kafka.ssl.tlsKeyPassword：SSL 相关的证书路径和密码。kafka.readTimeout：读取超时时间（秒）。
示例：
kafka:
brokerList:
- "localhost:9092"
saslUsername: "kafka_user"
saslPassword: "kafka_password"
saslMechanisms: "PLAIN"
securityProtocol: "SASL_SSL"
ssl:
enabled: true
tlsCert: "/path/to/client_cert.pem"
tlsKey: "/path/to/client_key.pem"
tlsCaCert: "/path/to/ca_cert.pem"
tlsKeyPassword: "key_password"
readTimeout: 10
说明：Kafka 是一种高吞吐量的分布式消息队列系统，适用于需要高并发和高可用性的消息传递场景。配置正确的 Kafka 参数，确保消息传递的可靠性和安全性。
10. natsmq
用途：配置 Natsmq 作为 Milvus 的消息队列系统。
详细说明：Natsmq 需要配置 NATS 服务器的相关参数，确保 Milvus 能够正确连接和使用 NATS 服务。
参考文档：NATS 官方配置文档
示例：
natsmq:
server_url: "nats://localhost:4222"
subject: "milvus_msgs"
说明：NATS 是一个轻量级、高性能的消息系统，适用于需要快速消息传递和低延迟的应用场景。
11. rootCoord
用途：配置 rootCoord，用于处理数据定义语言（DDL）和数据控制语言（DCL）请求。
关键参数：
rootCoord.port：rootCoord服务的端口。rootCoord.timeout：rootCoord操作的超时时间。rootCoord.max_retries：最大重试次数。
示例：
rootCoord:
port: 19531
timeout: 5
max_retries: 3
说明：rootCoord 是 Milvus 的协调组件，负责管理集合的创建、修改和删除等操作，确保系统的一致性和可靠性。
12. proxy
用途：配置 proxy，用于验证客户端请求并减少返回结果。
关键参数：
proxy.port：proxy服务的端口。proxy.timeout：proxy操作的超时时间。proxy.max_connections：最大连接数。
示例：
proxy:
port: 19530
timeout: 5
max_connections: 1000
说明：proxy 组件作为 Milvus 的入口，处理客户端的请求，进行身份验证、权限检查，并将请求转发给相应的协调组件或节点。
13. queryCoord
用途：配置 queryCoord，用于管理查询节点的拓扑结构和负载均衡，以及处理从增长段到封闭段的数据移交。
关键参数：
queryCoord.port：queryCoord服务的端口。queryCoord.timeout：queryCoord操作的超时时间。queryCoord.max_retries：最大重试次数。
示例：
queryCoord:
port: 19532
timeout: 5
max_retries: 3
说明：queryCoord 负责协调查询请求的分配和执行，确保查询的高效和负载的均衡。
14. queryNode
用途：配置 queryNode，用于执行向量和标量数据之间的混合搜索。
关键参数：
queryNode.port：queryNode服务的端口。queryNode.timeout：queryNode操作的超时时间。queryNode.max_concurrent_queries：最大并发查询数。
示例：
queryNode:
port: 19533
timeout: 5
max_concurrent_queries: 100
说明：queryNode 是实际执行搜索操作的工作节点，处理查询请求并返回结果。
15. indexCoord
用途：配置 indexCoord，用于管理索引节点的拓扑结构和索引的创建、更新与删除。
关键参数：
indexCoord.port：indexCoord服务的端口。indexCoord.timeout：indexCoord操作的超时时间。indexCoord.max_retries：最大重试次数。
示例：
indexCoord:
port: 19534
timeout: 5
max_retries: 3
说明：indexCoord 确保索引的高效管理和优化，支持不同索引类型的创建和维护。
16. indexNode
用途：配置 indexNode，用于实际执行索引构建和维护操作。
关键参数：
indexNode.port：indexNode服务的端口。indexNode.timeout：indexNode操作的超时时间。indexNode.max_concurrent_indexes：最大并发索引数。
示例：
indexNode:
port: 19535
timeout: 5
max_concurrent_indexes: 10
说明：indexNode 是执行索引创建、更新和查询的工作节点，确保索引的高效和准确。
17. dataCoord
用途：配置 dataCoord，用于管理数据节点的拓扑结构和数据的分配与迁移。
关键参数：
dataCoord.port：dataCoord服务的端口。dataCoord.timeout：dataCoord操作的超时时间。dataCoord.max_retries：最大重试次数。
示例：
dataCoord:
port: 19536
timeout: 5
max_retries: 3
说明：dataCoord 确保数据在集群中的高效分布和迁移，优化数据存储和访问性能。
18. dataNode
用途：配置 dataNode，用于实际存储和管理向量数据。
关键参数：
dataNode.port：dataNode服务的端口。dataNode.timeout：dataNode操作的超时时间。dataNode.max_storage_size：每个dataNode的最大存储容量。
示例：
dataNode:
port: 19537
timeout: 5
max_storage_size: "1TB"
说明：dataNode 是实际存储向量数据的工作节点，处理数据的插入、删除和更新操作。
19. msgChannel
用途：配置 Milvus 的消息通道，用于内部组件之间的通信。
关键参数：
msgChannel.type：消息通道类型，如rabbitmq、kafka等。msgChannel.address：消息通道的地址。msgChannel.timeout：消息通道操作的超时时间。
示例：
msgChannel:
type: "kafka"
address: "localhost:9092"
timeout: 5
说明：msgChannel 配置涉及 Milvus 内部消息传递机制，确保各组件之间的高效通信和协调。
20. log
用途：配置 Milvus 的日志输出，包括日志级别、格式和存储路径。
关键参数：
log.level：日志级别，如info、debug、error。log.format：日志格式，如json或text。log.path：日志文件的存储路径。
示例：
log:
level: "info"
format: "json"
path: "/var/log/milvus/"
说明：log 配置帮助用户监控和调试 Milvus，通过调整日志级别和格式，可以获取必要的调试信息或减少日志噪音。
21. grpc
用途：配置 Milvus 的 gRPC 服务，用于客户端与服务器之间的通信。
关键参数：
grpc.port：gRPC 服务的端口。grpc.timeout：gRPC 操作的超时时间。grpc.max_message_length：gRPC 消息的最大长度。
示例：
grpc:
port: 19540
timeout: 5
max_message_length: 10485760 # 10MB
说明：gRPC 是 Milvus 的主要通信协议，确保客户端与 Milvus 服务器之间的高效和安全通信。
22. tls
用途：配置 Proxy 的 TLS 启用，确保客户端与 Milvus 之间的通信安全。
关键参数：
tls.enable：是否启用 TLS。tls.cert_path：TLS 证书文件路径。tls.key_path：TLS 私钥文件路径。tls.ca_cert_path：CA 证书文件路径。
示例：
tls:
enable: true
cert_path: "/path/to/cert.pem"
key_path: "/path/to/key.pem"
ca_cert_path: "/path/to/ca_cert.pem"
说明：启用 TLS 可以加密客户端与 Milvus 之间的通信，确保数据传输的安全性。
23. common
用途：配置通用参数，适用于多个 Milvus 组件。
关键参数：
common.timeout：全局操作的超时时间。common.max_connections：全局最大连接数。common.retry_policy：全局重试策略参数。
示例：
common:
timeout: 5
max_connections: 1000
retry_policy:
max_retries: 3
backoff_factor: 0.3
说明：common 配置包含适用于多个组件的通用参数，如操作超时时间、最大连接数和重试策略，帮助优化系统整体性能和稳定性。
24. quotaAndLimits
用途：配置 Milvus 的配额和限制，确保系统资源的合理使用和防止滥用。
关键参数：
-
默认启用
：
tt_protection：TT 保护，用于限制瞬时请求量。memory_protection：内存保护，防止内存溢出。disk_quota_protection：磁盘配额保护，限制磁盘使用量。
-
可选启用
：
dml_throughput_limit：DML（数据操作语言）吞吐量限制。ddl_dql_qps_limit：DDL 和 DQL（数据查询语言）的 QPS/RPS 限制。dql_queue_length_protection：DQL 队列长度保护。dql_latency_protection：DQL 延迟保护。dql_result_rate_protection：DQL 结果速率保护。force_deny_rw_requests：手动强制拒绝读写请求。
示例：
quotaAndLimits:
tt_protection:
enabled: true
max_requests_per_second: 100
memory_protection:
enabled: true
max_memory_usage: "8GB"
disk_quota_protection:
enabled: true
max_disk_usage: "500GB"
dml_throughput_limit:
enabled: true
max_dml_qps: 50
force_deny_rw_requests:
enabled: false
说明：通过配置配额和限制，Milvus 能够控制系统资源的使用，防止系统过载和滥用，确保系统的稳定性和可靠性。
25. trace
用途：配置 Milvus 的追踪功能，用于监控和分析系统性能，帮助诊断问题和优化性能。
关键参数：
trace.enabled：是否启用追踪。trace.service_url：追踪服务的 URL（如 Jaeger、Zipkin）。trace.sample_rate：追踪采样率。
示例：
trace:
enabled: true
service_url: "http://localhost:14268/api/traces"
sample_rate: 0.5
说明：启用追踪功能，可以通过集成的追踪工具监控 Milvus 的性能和操作，帮助开发者诊断和优化系统。
26. gpu
用途：配置 GPU 索引相关参数，优化 GPU 资源的使用。
关键参数：
gpu.memory_pool_size：GPU 内存池的大小，单位为 MB。gpu.max_mem_size：GPU 最大内存使用量，单位为 MB。gpu.init_mem_size：初始内存池大小，单位为 MB。
注意事项：
- 如果
initMemSize和maxMemSize都设置为零，Milvus 将自动初始化为可用 GPU 内存的一半，maxMemSize将设置为整个可用 GPU 内存。 - 设置的
maxMemSize不能超过实际 GPU 可用内存，否则可能导致 Milvus 崩溃。
示例：
gpu:
memory_pool_size: 4096 # 4GB
max_mem_size: 8192 # 8GB
init_mem_size: 2048 # 2GB
说明：GPU 索引能够大幅提升搜索性能，合理配置 GPU 内存池和最大内存使用量，确保 GPU 资源的高效利用和系统的稳定运行。
配置参数生效
启动时生效：所有配置参数仅在 Milvus 启动时生效。这意味着在修改配置文件后，需要重新启动 Milvus 服务以应用新的配置。
如何修改配置：
- 编辑配置文件：Milvus 的配置文件通常为
milvus.yaml，位于安装目录的conf文件夹中。 - 修改所需参数：根据需要调整各部分的参数。
- 重启 Milvus：应用新配置，需要停止并重新启动 Milvus 服务。
示例：
# 停止 Milvus
docker-compose down
# 启动 Milvus
docker-compose up -d
说明：确保在编辑配置文件时，遵循 YAML 的语法规则，避免格式错误导致 Milvus 启动失败。
配置最佳实践
为了确保 Milvus 系统的高效运行和稳定性，以下是一些配置最佳实践建议：
1. 根据应用需求调整配置
- 存储配置：
- 选择合适的存储后端：根据数据量和访问模式，选择适合的存储后端（如 MinIO/S3）。
- 配置存储路径：合理配置存储路径和容量限制，确保数据管理的高效性。
- 消息队列：
- 选择合适的消息队列类型：根据系统规模和性能需求，选择适合的消息队列类型（如 Pulsar、Kafka）。
- 配置消息队列参数：根据消息队列类型，合理配置连接参数和认证信息，确保消息传递的可靠性和安全性。
- 索引配置：
- 选择合适的索引类型：根据向量搜索的精度和速度需求，选择合适的索引类型（如 IVF_FLAT、HNSW）。
- 调整索引参数：根据具体应用场景，调整索引参数（如
nlist、efConstruction）以优化性能。
2. 资源分配与优化
- 内存管理：
- 配置合理的内存使用参数：确保 Milvus 有足够的内存来处理数据和搜索操作，避免内存溢出。
- 监控内存使用：使用监控工具实时监控 Milvus 的内存使用情况，及时调整配置参数。
- GPU 使用：
- 合理配置 GPU 内存池：根据 GPU 可用内存和应用需求，配置合适的
memory_pool_size和max_mem_size。 - 监控 GPU 使用：确保 GPU 资源被高效利用，避免因内存不足导致的系统崩溃。
- 合理配置 GPU 内存池：根据 GPU 可用内存和应用需求，配置合适的
3. 安全性配置
- 身份认证与授权：
- 启用身份认证：配置 etcd 和消息队列的认证机制，确保只有授权用户能够访问 Milvus 服务。
- 配置权限管理：通过
proxy和其他组件，配置不同用户或租户的访问权限，确保数据隔离和安全。
- TLS 加密：
- 启用 TLS：配置 TLS/SSL，加密客户端与 Milvus 之间的通信，确保数据传输的安全性。
- 管理证书：确保 TLS 证书和密钥的安全存储和管理，定期更新证书以防止泄露。
4. 监控与日志管理
- 日志级别：
- 调整日志级别：根据需要调整
log.level，在开发和调试阶段使用debug级别，生产环境中使用info或error级别，减少日志噪音。
- 调整日志级别：根据需要调整
- 追踪系统：
- 启用追踪功能：通过配置
trace，集成 Jaeger 或 Zipkin 等追踪工具，监控系统性能和操作。 - 分析追踪数据：利用追踪数据分析系统瓶颈，优化系统性能。
- 启用追踪功能：通过配置
5. 集群管理与扩展
- 分布式部署：
- 部署多节点集群：根据数据规模和查询需求，部署多个 Milvus 节点，确保系统的高可用性和可扩展性。
- 配置负载均衡：通过
queryCoord和dataCoord配置，实现查询和数据管理的负载均衡，提升系统整体性能。
- 负载均衡：
- 动态调整节点：根据系统负载和数据增长，动态添加或移除 Milvus 节点，保持系统性能和稳定性。
- 监控负载：实时监控 Milvus 集群的负载情况，及时调整配置参数和资源分配。
总结
Milvus 是一个功能强大且高性能的开源向量数据库，专为处理海量向量数据而设计。通过理解和合理配置 Milvus 的各项参数，您可以充分发挥其性能优势，满足不同应用场景的需求。以下是一些关键要点总结：
- 理解核心概念：
- 集合（Collection）、向量（Vector）、索引（Index）、分片（Shard） 和 副本（Replica） 是 Milvus 的核心概念，理解它们的作用和配置方法是使用 Milvus 的基础。
- 选择合适的部署模式：
- 根据数据规模和应用需求，选择适合的部署模式（如 Milvus Lite、Standalone 或 Distributed），确保系统的高效运行和可扩展性。
- 优化性能和可扩展性：
- 利用硬件感知优化、先进的搜索算法和列式存储等特性，提升 Milvus 的搜索和存储性能。
- 通过分布式部署和高度解耦的系统架构，实现系统的水平扩展和高可用性。
- 合理配置系统参数：
- 根据具体应用场景和需求，调整存储、消息队列、索引等相关配置，确保 Milvus 系统的高效运行。
- 使用监控和日志管理工具，实时监控系统性能，及时调整配置参数和资源分配。
- 确保系统安全性：
- 启用身份认证和授权机制，配置 TLS 加密，确保 Milvus 系统的安全性和数据的隐私保护。
- 利用丰富的 API 和 SDK：
- 使用 Milvus 提供的多种 API 和 SDK，轻松集成到各种应用中，支持多种编程语言的开发需求。
- 参与社区和利用工具生态：
- 通过 Milvus 的社区和工具生态，获取最新的功能更新和最佳实践，提升 Milvus 的使用效率和效果。
当然，我很高兴为您详细讲解《Quickstart with Milvus Lite》文档。这份文档旨在帮助用户快速上手 Milvus Lite，一个轻量级的 Milvus 版本，适用于本地开发和原型设计。以下是对文档的逐步解析和详细说明：
使用 Milvus Lite 的快速入门指南
Milvus 是一个高性能、可高度扩展的向量数据库，适用于从个人笔记本电脑到大规模分布式系统的各种环境。Milvus 提供开源软件和云服务版本，满足不同规模和需求的 AI 应用。
Milvus Lite 是 Milvus 的一个轻量级版本，作为 pymilvus 库的一部分，可以嵌入到客户端应用程序中。它特别适合在 Jupyter Notebook 中进行快速原型开发或在资源有限的边缘设备上运行。
向量、嵌入与 Milvus
向量（Vectors）
向量是神经网络模型的输出数据格式，能够有效地编码信息，并在知识库、语义搜索、检索增强生成（RAG）等 AI 应用中发挥关键作用。向量通过捕捉数据的高维特征，帮助实现高效的相似性搜索和分析。
嵌入（Embeddings）
嵌入技术用于将非结构化数据（如文本、图像、音频）转换为数值向量，这些向量能够捕捉数据的核心特征。通过这种方式，复杂的非结构化数据可以在向量数据库中进行高效存储和检索。
Milvus 的作用
Milvus 提供强大的数据建模能力，允许您将非结构化或多模态数据组织成结构化的集合。它支持多种数据类型，包括数值类型、字符类型、各种向量类型、数组、集合和 JSON，避免了维护多个数据库系统的复杂性。
Milvus Lite 快速入门
Milvus Lite 是一个 Python 库，内置于 pymilvus 中，可以轻松嵌入到您的应用程序中。本文将指导您如何在本地环境中快速安装和使用 Milvus Lite，通过 Python 客户端库生成、存储和搜索向量。
1. 安装 Milvus Lite
在本指南中，我们使用 Milvus Lite，它是 pymilvus 库的一部分。Milvus 还支持通过 Docker 和 Kubernetes 部署以适应生产环境需求。
系统要求
- Python 版本：Python 3.8 及以上
- 依赖：确保本地环境中安装了必要的库和工具，如
pymilvus。
安装步骤
-
安装
pymilvus使用
pip安装pymilvus，这将包括 Milvus Lite 的所有必要组件：pip install -U pymilvus注意：如果您使用的是 Google Colab，为了使新安装的依赖生效，可能需要重新启动运行时。可以通过点击顶部菜单栏的“Runtime”，然后选择“Restart session”来完成。
2. 设置向量数据库
创建一个本地 Milvus 向量数据库非常简单，只需实例化一个 MilvusClient，并指定一个文件名用于存储所有数据，例如 "milvus_demo.db"。
from pymilvus import MilvusClient
# 创建一个 MilvusClient 实例，数据将存储在 "milvus_demo.db" 文件中
client = MilvusClient("milvus_demo.db")
3. 创建集合
在 Milvus 中，集合（Collection）用于存储向量及其相关的元数据。可以将其视为传统 SQL 数据库中的表。创建集合时，可以定义模式（Schema）和索引参数，以配置向量的规格，如维度、索引类型和距离度量。本文将重点介绍基本操作，使用默认参数。
基本创建集合
# 如果集合已存在，则删除它
if client.has_collection(collection_name="demo_collection"):
client.drop_collection(collection_name="demo_collection")
# 创建一个新的集合
client.create_collection(
collection_name="demo_collection",
dimension=768, # 本示例中使用的向量有 768 维
)
说明
-
集合名称：
demo_collection是集合的名称。 -
维度：
dimension=768指定向量的维度为 768。 -
默认参数
：
- 主键和向量字段：使用默认名称 “id” 和 “vector”。
- 距离度量：默认使用余弦相似度（COSINE）。
- 主键类型：主键字段接受整数，并且不自动递增（即不使用自动 ID 功能）。
注意：您可以通过正式定义集合的模式（Schema）来配置更多详细参数，详见官方文档。
4. 准备数据
本指南将使用向量在文本上执行语义搜索。首先需要生成文本的向量嵌入，可以通过下载和使用嵌入模型来完成。这可以通过 pymilvus[model] 库中的实用函数轻松实现。
表示文本为向量
-
安装嵌入模型库
该包包括必要的机器学习工具，如 PyTorch。首次安装可能需要一些时间，因为需要下载 PyTorch。
pip install "pymilvus[model]" -
生成向量嵌入
使用默认的嵌入函数，Milvus 期望插入的数据以字典列表的形式组织，每个字典代表一个数据记录，称为实体（Entity）。
from pymilvus import model # 如果无法连接到 https://huggingface.co/，可以取消注释以下路径 # import os # os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com' # 这将下载一个小型嵌入模型 "paraphrase-albert-small-v2" (~50MB) embedding_fn = model.DefaultEmbeddingFunction() # 要搜索的文本字符串 docs = [ "Artificial intelligence was founded as an academic discipline in 1956.", "Alan Turing was the first person to conduct substantial research in AI.", "Born in Maida Vale, London, Turing was raised in southern England.", ] # 生成向量嵌入 vectors = embedding_fn.encode_documents(docs) print("Dim:", embedding_fn.dim, vectors[0].shape) # 输出：Dim: 768 (768,) # 每个实体包含 id、向量表示、原始文本和主题标签（用于后续的元数据过滤） data = [ {"id": i, "vector": vectors[i], "text": docs[i], "subject": "history"} for i in range(len(vectors)) ] print("Data has", len(data), "entities, each with fields: ", data[0].keys()) print("Vector dim:", len(data[0]["vector"]))输出示例：
Dim: 768 (768,) Data has 3 entities, each with fields: dict_keys(['id', 'vector', 'text', 'subject']) Vector dim: 768
使用假向量表示（可选）
如果由于网络问题无法下载模型，可以使用随机向量来表示文本，尽管这样搜索结果不会反映语义相似性。
import random
# 要搜索的文本字符串
docs = [
"Artificial intelligence was founded as an academic discipline in 1956.",
"Alan Turing was the first person to conduct substantial research in AI.",
"Born in Maida Vale, London, Turing was raised in southern England.",
]
# 使用随机向量（768 维）
vectors = [[random.uniform(-1, 1) for _ in range(768)] for _ in docs]
data = [
{"id": i, "vector": vectors[i], "text": docs[i], "subject": "history"}
for i in range(len(vectors))
]
print("Data has", len(data), "entities, each with fields: ", data[0].keys())
print("Vector dim:", len(data[0]["vector"]))
输出示例：
Data has 3 entities, each with fields: dict_keys(['id', 'vector', 'text', 'subject'])
Vector dim: 768
5. 插入数据
将准备好的数据插入到集合中：
res = client.insert(collection_name="demo_collection", data=data)
print(res)
输出示例：
{'insert_count': 3, 'ids': [0, 1, 2], 'cost': 0}
说明：
insert_count: 插入的实体数量。ids: 插入实体的主键 ID 列表。cost: 插入操作的耗时（单位可能是毫秒）。
6. 语义搜索
现在可以通过将查询文本表示为向量，执行向量相似性搜索来进行语义搜索。
向量搜索
Milvus 支持一次接受一个或多个向量搜索请求。query_vectors 的值是一个向量列表，每个向量是一个浮点数数组。
# 生成查询向量
query_vectors = embedding_fn.encode_queries(["Who is Alan Turing?"])
# 如果没有嵌入函数，可以使用假向量完成示例：
# query_vectors = [ [ random.uniform(-1, 1) for _ in range(768) ] ]
# 执行搜索
res = client.search(
collection_name="demo_collection", # 目标集合
data=query_vectors, # 查询向量
limit=2, # 返回实体数量
output_fields=["text", "subject"], # 指定返回的字段
)
print(res)
输出示例：
data: ["[{'id': 2, 'distance': 0.5859944820404053, 'entity': {'text': 'Born in Maida Vale, London, Turing was raised in southern England.', 'subject': 'history'}}, {'id': 1, 'distance': 0.5118255615234375, 'entity': {'text': 'Alan Turing was the first person to conduct substantial research in AI.', 'subject': 'history'}}]"] , extra_info: {'cost': 0}
说明：
- 结果结构：结果是一个列表，每个查询对应一个子列表，子列表中的每个元素包含实体的主键 ID、与查询向量的距离以及指定的返回字段（如
text和subject）。 - 距离度量：在本例中，使用余弦相似度（COSINE），距离越小表示越相似。
带元数据过滤的向量搜索
可以在执行向量搜索的同时，根据元数据（称为标量字段）进行过滤。例如，仅搜索主题为“biology”的文档。
# 插入更多文档，主题为 biology
docs = [
"Machine learning has been used for drug design.",
"Computational synthesis with AI algorithms predicts molecular properties.",
"DDR1 is involved in cancers and fibrosis.",
]
vectors = embedding_fn.encode_documents(docs)
data = [
{"id": 3 + i, "vector": vectors[i], "text": docs[i], "subject": "biology"}
for i in range(len(vectors))
]
# 插入新数据
client.insert(collection_name="demo_collection", data=data)
# 执行带过滤条件的搜索，仅返回 subject 为 'biology' 的实体
res = client.search(
collection_name="demo_collection",
data=embedding_fn.encode_queries(["tell me AI related information"]),
filter="subject == 'biology'",
limit=2,
output_fields=["text", "subject"],
)
print(res)
输出示例：
data: ["[{'id': 4, 'distance': 0.27030569314956665, 'entity': {'text': 'Computational synthesis with AI algorithms predicts molecular properties.', 'subject': 'biology'}}, {'id': 3, 'distance': 0.16425910592079163, 'entity': {'text': 'Machine learning has been used for drug design.', 'subject': 'biology'}}]"] , extra_info: {'cost': 0}
说明：
- 过滤条件：通过
filter="subject == 'biology'"，仅返回符合条件的实体。 - 性能提示：默认情况下，标量字段未建立索引。如果在大规模数据集上执行带过滤条件的搜索，建议使用固定模式并开启索引以提升搜索性能。
7. 查询操作
除了向量搜索，Milvus 还支持其他类型的查询操作：
查询（Query）
查询操作用于检索符合特定条件的所有实体，如过滤表达式或匹配某些 ID。
示例：根据标量字段值检索实体
# 检索所有 subject 为 'history' 的实体
res = client.query(
collection_name="demo_collection",
filter="subject == 'history'",
output_fields=["text", "subject"],
)
print(res)
示例：通过主键直接检索实体
# 通过主键 ID 检索实体
res = client.query(
collection_name="demo_collection",
ids=[0, 2],
output_fields=["vector", "text", "subject"],
)
print(res)
8. 删除实体
如果需要清除数据，可以通过指定主键 ID 或使用过滤表达式删除实体。
按主键删除实体
# 按主键 ID 删除实体
res = client.delete(collection_name="demo_collection", ids=[0, 2])
print(res)
按过滤条件删除实体
# 按过滤条件删除 subject 为 'biology' 的实体
res = client.delete(
collection_name="demo_collection",
filter="subject == 'biology'",
)
print(res)
输出示例：
[]
[]
说明：
- 删除操作成功后，返回一个空列表，表示没有剩余的实体符合删除条件。
9. 加载现有数据
由于 Milvus Lite 的所有数据都存储在本地文件中，即使程序终止后，也可以通过指定现有文件来加载所有数据。这允许您恢复之前的集合和数据，并继续在其上进行操作。
from pymilvus import MilvusClient
# 创建一个 MilvusClient 实例，加载现有的 "milvus_demo.db" 文件
client = MilvusClient("milvus_demo.db")
说明：
- 数据持久化：Milvus Lite 的数据持久化机制确保数据在程序重启后依然可用。
- 继续操作：加载现有数据后，可以继续插入、搜索、查询等操作。
10. 删除集合
如果需要删除集合中的所有数据，可以通过删除集合来实现。
# 删除集合
client.drop_collection(collection_name="demo_collection")
说明：
- 删除操作：
drop_collection会删除整个集合及其所有数据，无法恢复，请谨慎操作。
进一步学习
Milvus Lite 适合在本地 Python 程序中快速入门和开发原型。如果您需要处理大规模数据或希望在生产环境中使用 Milvus，可以学习如何在 Docker 和 Kubernetes 上部署 Milvus。所有 Milvus 部署模式共享相同的 API，因此在迁移到其他部署模式时，客户端代码无需做太大修改。只需指定 Milvus 服务器的 URI 和 Token 即可：
client = MilvusClient(uri="http://localhost:19530", token="root:Milvus")
Milvus 提供以下 API 和 SDK：
- RESTful API（官方）
- PyMilvus（Python SDK，官方）
- Go SDK（官方）
- Java SDK（官方）
- Node.js（JavaScript）SDK（官方）
- C# SDK（由 Microsoft 贡献）
总结
通过本指南，您已经学习了如何使用 Milvus Lite 在本地环境中快速设置和使用 Milvus 向量数据库。以下是关键步骤的总结：
- 安装
pymilvus：确保 Python 环境中安装了pymilvus库。 - 创建 MilvusClient 实例：指定数据存储文件，创建本地向量数据库。
- 创建集合：定义集合名称和向量维度，创建用于存储向量和元数据的集合。
- 准备数据：使用嵌入模型将文本转换为向量，组织成实体格式。
- 插入数据：将实体数据插入到 Milvus 集合中。
- 执行语义搜索：通过向量相似性搜索和元数据过滤，检索相关实体。
- 执行查询操作：包括基于过滤条件和主键的查询。
- 删除实体：根据主键或过滤条件删除不需要的实体。
- 加载现有数据：通过指定数据存储文件，恢复和继续操作已有数据。
- 删除集合：根据需要删除整个集合及其数据。
进一步学习建议：
- 探索更多功能：如高级索引配置、批量操作、持久化和备份等。
- 了解部署选项：学习如何在 Docker 和 Kubernetes 上部署 Milvus，以应对生产环境需求。
- 参与社区：通过 Milvus 官方文档、论坛和社区获取最新资讯和支持。
- 实践项目：结合实际项目，深入理解 Milvus 的应用和优化技巧。
如果您在使用 Milvus Lite 时遇到任何问题，欢迎参考 Milvus 官方文档 或加入 Milvus 社区寻求帮助。
当然，我很高兴继续为您详细讲解《Run Milvus Lite Locally》文档。这部分内容主要介绍了如何在本地环境中运行 Milvus Lite，包括安装、配置、示例操作以及 Milvus Lite 的使用限制。以下是对文档的逐步解析和详细说明：
在本地运行 Milvus Lite
Milvus Lite 是 Milvus 的轻量级版本，是一个开源的向量数据库，专为 AI 应用设计，支持向量嵌入和相似性搜索。Milvus Lite 可以轻松嵌入到 Python 应用程序中，适用于快速开发和学习阶段。
概述
Milvus Lite 可以导入到您的 Python 应用程序中，提供 Milvus 的核心向量搜索功能。Milvus Lite 已经包含在 Milvus 的 Python SDK 中，可以通过以下命令简单部署：
pip install -U pymilvus
使用 Milvus Lite，您可以在几分钟内开始构建具有向量相似性搜索功能的 AI 应用！Milvus Lite 适用于以下环境：
- Jupyter Notebook / Google Colab：适合交互式开发和实验。
- 笔记本电脑：适用于个人开发和测试。
- 边缘设备：适用于资源有限的设备，如 IoT 设备或移动设备。
Milvus Lite 与 Milvus Standalone 和 Milvus Distributed 共享相同的 API，并覆盖了大部分功能，如向量数据的持久化与管理、向量的 CRUD 操作、稀疏和密集向量搜索、元数据过滤、多向量和混合搜索等。这些功能在不同类型的环境中提供一致的体验，从边缘设备到云中的集群，适应不同规模的使用场景。通过相同的客户端代码，您可以在笔记本电脑或 Jupyter Notebook 上使用 Milvus Lite 运行生成式 AI 应用，或者在 Docker 容器中使用 Milvus Standalone，甚至在生产环境中使用 Kubernetes 集群部署的 Milvus Distributed 来服务数十亿个向量。
前提条件
Milvus Lite 当前支持以下环境：
- Ubuntu >= 20.04（支持 x86_64 和 arm64 架构）
- MacOS >= 11.0（支持 Apple Silicon M1/M2 和 x86_64 架构）
注意：Milvus Lite 仅适用于小规模的向量搜索用例。对于大规模用例，建议使用 Milvus Standalone 或 Milvus Distributed。您还可以考虑使用 Zilliz Cloud 上的完全托管 Milvus 服务。
设置 Milvus Lite
安装 pymilvus
推荐使用 pymilvus。由于 Milvus Lite 包含在 pymilvus 版本 2.4.2 或更高版本中，您可以使用以下命令通过 pip 安装并强制更新到最新版本，Milvus Lite 会自动安装：
pip install -U pymilvus
如果您希望显式安装 milvus-lite 包，或者您已经安装了较旧版本的 Milvus Lite 并希望更新，可以使用以下命令：
pip install -U milvus-lite
连接到 Milvus Lite
在 pymilvus 中，通过指定本地文件名作为 uri 参数，MilvusClient 将使用 Milvus Lite。
from pymilvus import MilvusClient
# 创建一个 MilvusClient 实例，数据将存储在 "milvus_demo.db" 文件中
client = MilvusClient("./milvus_demo.db")
说明：运行上述代码后，会在当前文件夹中生成一个名为 milvus_demo.db 的数据库文件。
注意：相同的 API 也适用于 Milvus Standalone、Milvus Distributed 和 Zilliz Cloud，唯一的区别是将本地文件名替换为远程服务器的端点和凭证。例如：
# 连接到服务器部署的 Milvus client = MilvusClient(uri="http://localhost:19530", token="root:Milvus")
示例操作
以下是一个简单的示例，展示如何使用 Milvus Lite 进行文本搜索。更全面的示例包括使用 Milvus Lite 构建 RAG、图像搜索，以及在流行的 RAG 框架（如 LangChain 和 LlamaIndex）中使用 Milvus Lite！
1. 导入必要的库并连接到 Milvus Lite
from pymilvus import MilvusClient
import numpy as np
# 连接到本地的 Milvus Lite
client = MilvusClient("./milvus_demo.db")
2. 创建集合
在 Milvus 中，集合（Collection）用于存储向量及其相关的元数据。可以将其视为传统 SQL 数据库中的表。创建集合时，可以定义模式（Schema）和索引参数，以配置向量的规格，如维度、索引类型和距离度量。本示例将使用默认参数，只设置集合名称和向量维度。
client.create_collection(
collection_name="demo_collection",
dimension=384 # 本示例中使用的向量有 384 维
)
说明：
-
集合名称：
demo_collection是集合的名称。 -
维度：
dimension=384指定向量的维度为 384。 -
默认参数
：
- 主键和向量字段：使用默认名称 “id” 和 “vector”。
- 距离度量：默认使用余弦相似度（COSINE）。
- 主键类型：主键字段接受整数，并且不自动递增（即不使用自动 ID 功能）。
3. 准备数据
在本示例中，我们将使用向量在文本上执行语义搜索。由于网络问题，无法下载模型时，可以使用随机向量作为替代。以下两个方法分别展示了使用嵌入模型生成向量和使用随机向量表示文本的两种方式。
3.1 使用嵌入模型表示文本
from pymilvus import model
# 如果无法连接到 https://huggingface.co/，可以取消注释以下路径
# import os
# os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com'
# 这将下载一个小型嵌入模型 "paraphrase-albert-small-v2" (~50MB)
embedding_fn = model.DefaultEmbeddingFunction()
# 要搜索的文本字符串
docs = [
"Artificial intelligence was founded as an academic discipline in 1956.",
"Alan Turing was the first person to conduct substantial research in AI.",
"Born in Maida Vale, London, Turing was raised in southern England.",
]
# 生成向量嵌入
vectors = embedding_fn.encode_documents(docs)
print("Dim:", embedding_fn.dim, vectors[0].shape) # 输出：Dim: 384 (384,)
# 每个实体包含 id、向量表示、原始文本和主题标签（用于后续的元数据过滤）
data = [
{"id": i, "vector": vectors[i], "text": docs[i], "subject": "history"}
for i in range(len(vectors))
]
print("Data has", len(data), "entities, each with fields: ", data[0].keys())
print("Vector dim:", len(data[0]["vector"]))
输出示例：
Dim: 384 (384,)
Data has 3 entities, each with fields: dict_keys(['id', 'vector', 'text', 'subject'])
Vector dim: 384
3.2 使用随机向量表示（可选）
如果由于网络问题无法下载模型，可以使用随机向量来表示文本，尽管这样搜索结果不会反映语义相似性。
import random
# 要搜索的文本字符串
docs = [
"Artificial intelligence was founded as an academic discipline in 1956.",
"Alan Turing was the first person to conduct substantial research in AI.",
"Born in Maida Vale, London, Turing was raised in southern England.",
]
# 使用随机向量（384 维）
vectors = [[random.uniform(-1, 1) for _ in range(384)] for _ in docs]
data = [
{"id": i, "vector": vectors[i], "text": docs[i], "subject": "history"}
for i in range(len(vectors))
]
print("Data has", len(data), "entities, each with fields: ", data[0].keys())
print("Vector dim:", len(data[0]["vector"]))
输出示例：
Data has 3 entities, each with fields: dict_keys(['id', 'vector', 'text', 'subject'])
Vector dim: 384
4. 插入数据
将准备好的数据插入到集合中：
res = client.insert(
collection_name="demo_collection",
data=data
)
print(res)
输出示例：
{'insert_count': 3, 'ids': [0, 1, 2], 'cost': 0}
说明：
insert_count: 插入的实体数量。ids: 插入实体的主键 ID 列表。cost: 插入操作的耗时（单位可能是毫秒）。
5. 语义搜索
现在可以通过将查询文本表示为向量，执行向量相似性搜索来进行语义搜索。
5.1 向量搜索
Milvus 支持一次接受一个或多个向量搜索请求。query_vectors 的值是一个向量列表，每个向量是一个浮点数数组。
# 生成查询向量
query_vectors = embedding_fn.encode_queries(["Who is Alan Turing?"])
# 如果没有嵌入函数，可以使用假向量完成示例：
# query_vectors = [ [ random.uniform(-1, 1) for _ in range(384) ] ]
# 执行搜索
res = client.search(
collection_name="demo_collection", # 目标集合
data=query_vectors, # 查询向量
limit=2, # 返回实体数量
output_fields=["text", "subject"], # 指定返回的字段
)
print(res)
输出示例：
data: ["[{'id': 2, 'distance': 0.5859944820404053, 'entity': {'text': 'Born in Maida Vale, London, Turing was raised in southern England.', 'subject': 'history'}}, {'id': 1, 'distance': 0.5118255615234375, 'entity': {'text': 'Alan Turing was the first person to conduct substantial research in AI.', 'subject': 'history'}}]"] , extra_info: {'cost': 0}
说明：
- 结果结构：结果是一个列表，每个查询对应一个子列表，子列表中的每个元素包含实体的主键 ID、与查询向量的距离以及指定的返回字段（如
text和subject）。 - 距离度量：在本例中，使用余弦相似度（COSINE），距离越小表示越相似。
5.2 带元数据过滤的向量搜索
可以在执行向量搜索的同时，根据元数据（称为标量字段）进行过滤。例如，仅搜索主题为“biology”的文档。
# 插入更多文档，主题为 biology
docs = [
"Machine learning has been used for drug design.",
"Computational synthesis with AI algorithms predicts molecular properties.",
"DDR1 is involved in cancers and fibrosis.",
]
vectors = embedding_fn.encode_documents(docs)
data = [
{"id": 3 + i, "vector": vectors[i], "text": docs[i], "subject": "biology"}
for i in range(len(vectors))
]
# 插入新数据
client.insert(
collection_name="demo_collection",
data=data
)
# 执行带过滤条件的搜索，仅返回 subject 为 'biology' 的实体
res = client.search(
collection_name="demo_collection",
data=embedding_fn.encode_queries(["tell me AI related information"]),
filter="subject == 'biology'",
limit=2,
output_fields=["text", "subject"],
)
print(res)
输出示例：
data: ["[{'id': 4, 'distance': 0.27030569314956665, 'entity': {'text': 'Computational synthesis with AI algorithms predicts molecular properties.', 'subject': 'biology'}}, {'id': 3, 'distance': 0.16425910592079163, 'entity': {'text': 'Machine learning has been used for drug design.', 'subject': 'biology'}}]"] , extra_info: {'cost': 0}
说明：
- 过滤条件：通过
filter="subject == 'biology'"，仅返回符合条件的实体。 - 性能提示：默认情况下，标量字段未建立索引。如果在大规模数据集上执行带过滤条件的搜索，建议使用固定模式并开启索引以提升搜索性能。
6. 查询操作
除向量搜索外，Milvus 还支持其他类型的查询操作：
6.1 查询（Query）
查询操作用于检索符合特定条件的所有实体，如过滤表达式或匹配某些 ID。
示例：根据标量字段值检索实体
# 检索所有 subject 为 'history' 的实体
res = client.query(
collection_name="demo_collection",
filter="subject == 'history'",
output_fields=["text", "subject"],
)
print(res)
示例：通过主键直接检索实体
# 通过主键 ID 检索实体
res = client.query(
collection_name="demo_collection",
ids=[0, 2],
output_fields=["vector", "text", "subject"],
)
print(res)
7. 删除实体
如果需要清除数据，可以通过指定主键 ID 或使用过滤表达式删除实体。
7.1 按主键删除实体
# 按主键 ID 删除实体
res = client.delete(
collection_name="demo_collection",
ids=[0, 2]
)
print(res)
7.2 按过滤条件删除实体
# 按过滤条件删除 subject 为 'biology' 的实体
res = client.delete(
collection_name="demo_collection",
filter="subject == 'biology'",
)
print(res)
输出示例：
[]
[]
说明：
- 删除操作成功后，返回一个空列表，表示没有剩余的实体符合删除条件。
8. 加载现有数据
由于 Milvus Lite 的所有数据都存储在本地文件中，即使程序终止后，也可以通过指定现有文件来加载所有数据。这允许您恢复之前的集合和数据，并继续在其上进行操作。
from pymilvus import MilvusClient
# 创建一个 MilvusClient 实例，加载现有的 "milvus_demo.db" 文件
client = MilvusClient("milvus_demo.db")
说明：
- 数据持久化：Milvus Lite 的数据持久化机制确保数据在程序重启后依然可用。
- 继续操作：加载现有数据后，可以继续插入、搜索、查询等操作。
9. 删除集合
如果需要删除集合中的所有数据，可以通过删除集合来实现。
# 删除集合
client.drop_collection(collection_name="demo_collection")
说明：
- 删除操作：
drop_collection会删除整个集合及其所有数据，无法恢复，请谨慎操作。
使用限制
在运行 Milvus Lite 时，需要注意一些功能不受支持。以下表格总结了 Milvus Lite 的使用限制。
1. 集合（Collection）
| 方法 / 参数 | Milvus Lite 支持 |
|---|---|
create_collection() | 支持，参数有限制 |
collection_name | 是 |
dimension | 是 |
primary_field_name | 是 |
id_type | 是 |
vector_field_name | 是 |
metric_type | 是 |
auto_id | 是 |
schema | 是 |
index_params | 是 |
enable_dynamic_field | 是 |
num_shards | 否 |
partition_key_field | 否 |
num_partitions | 否 |
consistency_level | 否（仅支持 Strong） |
get_collection_stats() | 支持，获取集合统计信息 |
describe_collection() | num_shards, consistency_level, collection_id 在响应中无效 |
has_collection() | 支持，检查集合是否存在 |
list_collections() | 支持，列出所有集合 |
drop_collection() | 支持，删除集合 |
rename_collection() | 不支持 |
2. 字段与模式（Field & Schema）
| 方法 / 参数 | Milvus Lite 支持 |
|---|---|
create_schema() | 支持，参数有限制 |
auto_id | 是 |
enable_dynamic_field | 是 |
primary_field | 是 |
partition_key_field | 否 |
add_field() | 支持，参数有限制 |
field_name | 是 |
datatype | 是 |
is_primary | 是 |
max_length | 是 |
element_type | 是 |
max_capacity | 是 |
dim | 是 |
is_partition_key | 否 |
3. 插入与搜索（Insert & Search）
| 方法 / 参数 | Milvus Lite 支持 |
|---|---|
search() | 支持，参数有限制 |
collection_name | 是 |
data | 是 |
filter | 是 |
limit | 是 |
output_fields | 是 |
search_params | 是 |
timeout | 是 |
partition_names | 否 |
anns_field | 是 |
query() | 支持，参数有限制 |
get() | 支持，参数有限制 |
delete() | 支持，参数有限制 |
insert() | 支持，参数有限制 |
upsert() | 支持，参数有限制 |
4. 加载与释放（Load & Release）
| 方法 / 参数 | Milvus Lite 支持 |
|---|---|
load_collection() | 是 |
release_collection() | 是 |
get_load_state() | 不支持 |
refresh_load() | 不支持 |
close() | 是 |
5. 索引（Index）
| 方法 / 参数 | Milvus Lite 支持 |
|---|---|
list_indexes() | 支持，列出索引 |
collection_name | 是 |
field_name | 是 |
create_index() | 仅支持 FLAT 索引类型 |
index_params | 是 |
timeout | 是 |
drop_index() | 支持，删除索引 |
index_name | 是 |
describe_index() | 支持，描述索引 |
6. 向量索引类型（Vector Index Types）
Milvus Lite 仅支持 FLAT 索引类型。无论在集合中指定何种索引类型，Milvus Lite 都会使用 FLAT 类型。
7. 搜索功能（Search Features）
Milvus Lite 支持以下搜索功能：
- 稀疏向量（Sparse Vector）
- 多向量（Multi-vector）
- 混合搜索（Hybrid Search）
8. 分区（Partition）
Milvus Lite 不支持分区及其相关方法。
9. 用户与角色（Users & Roles）
Milvus Lite 不支持用户和角色及其相关方法。
10. 别名（Alias）
Milvus Lite 不支持别名及其相关方法。
从 Milvus Lite 迁移数据
所有存储在 Milvus Lite 中的数据都可以轻松导出并加载到其他类型的 Milvus 部署中，如 Docker 上的 Milvus Standalone、Kubernetes 上的 Milvus Distributed，或 Zilliz Cloud 上的完全托管 Milvus 服务。
Milvus Lite 提供了一个命令行工具，可以将数据导出为 JSON 文件，这些文件可以导入到 Milvus 服务器和 Zilliz Cloud 中。milvus-lite 命令会随着 milvus-lite Python 包一起安装。
安装
pip install -U "pymilvus[bulk_writer]"
使用命令行工具导出数据
查看帮助信息：
milvus-lite dump -h
使用示例：
将 demo_collection 集合中的所有数据从 ./milvus_demo.db 数据库文件导出到 ./data_dir 目录中：
milvus-lite dump -d ./milvus_demo.db -c demo_collection -p ./data_dir
参数说明：
-d,--db-file：Milvus Lite 数据库文件路径。-c,--collection：需要导出的集合名称。-p,--path：导出文件的存储目录。
导出后，您可以使用以下方法将数据上传到 Zilliz Cloud（Milvus 的完全托管云服务）或其他 Milvus 服务器：
- Zilliz Cloud：通过数据导入功能上传导出的 JSON 文件。
- Milvus 服务器：通过批量插入功能（Bulk Insert）上传导出的 JSON 文件。
接下来的步骤
连接到 Milvus Lite 后，您可以继续探索和学习 Milvus 的更多功能和操作。以下是一些建议的学习路径：
1. 检查快速入门（Quickstart）
查看快速入门指南，了解 Milvus 能够完成的基本任务和操作。
2. 学习 Milvus 的基本操作
- 管理数据库（Manage Databases）：了解如何创建、删除和管理数据库。
- 管理集合（Manage Collections）：学习如何创建、删除和管理集合。
- 管理分区（Manage Partitions）：虽然 Milvus Lite 不支持分区，但了解如何在其他部署模式中管理分区是有益的。
- 插入、更新和删除（Insert, Upsert & Delete）：掌握数据的增删改查操作。
- 单向量搜索（Single-Vector Search）：执行基于单个查询向量的相似性搜索。
- 混合搜索（Hybrid Search）：结合多个查询向量或元数据执行复杂搜索。
- 使用 Helm Chart 升级 Milvus（Upgrade Milvus Using Helm Chart）：学习如何使用 Helm Chart 升级 Milvus 部署。
3. 扩展 Milvus 集群
-
扩展 Milvus 集群：了解如何扩展 Milvus 集群以处理更大的数据量和更高的查询负载。
-
在云上部署 Milvus 集群
：
- Amazon EKS
- Google Cloud
- Microsoft Azure
4. 探索 Milvus 的工具和生态系统
- Milvus Backup：探索一个用于 Milvus 数据备份的开源工具。
- Birdwatcher：一个用于调试 Milvus 和动态配置更新的开源工具。
- Attu：一个用于直观管理 Milvus 的开源 GUI 工具。
- Prometheus 集成：使用 Prometheus 监控 Milvus 的性能。
总结
Milvus Lite 与服务器部署的 Milvus 的区别
尽管 Milvus Lite 与服务器部署的 Milvus 在代码使用层面具有高度一致性，但它们在部署架构、功能和性能方面存在一些关键区别：
- 部署架构：
- Milvus Lite：嵌入式库，适用于本地开发和小规模应用。
- 服务器部署的 Milvus：独立服务，支持分布式部署和大规模数据处理。
- 功能与性能：
- Milvus Lite：功能有限，仅支持基本的向量搜索和数据管理，适用于小规模数据集。
- 服务器部署的 Milvus：支持所有高级功能，包括多种索引类型、分区管理、高可用性和扩展性，适用于生产环境和大规模数据处理。
- 配置与管理：
- Milvus Lite：无需复杂的配置和维护，适合快速上手和学习。
- 服务器部署的 Milvus：需要配置集群管理、安全设置等，更适合生产环境。
学习阶段的建议
- 使用 Milvus Lite 学习：由于 Milvus Lite 的安装和使用非常简便，您可以在本地环境中快速上手，熟悉 Milvus 的基本操作和 API。这对于学习向量数据库的工作原理和功能非常有帮助。
- 代码一致性：Milvus Lite 和服务器部署的 Milvus 使用相同的
pymilvus客户端库和 API，大部分代码可以无缝迁移。这意味着您在 Milvus Lite 中积累的经验和编写的代码在未来迁移到服务器部署时几乎无需修改。 - 实践项目：通过在 Milvus Lite 中构建实际项目，如文本搜索、图像搜索等，积累实际操作经验。这将为将来在生产环境中使用 Milvus 奠定坚实的基础。
未来的迁移
当您准备好处理更大规模的数据或需要在生产环境中使用 Milvus 时，可以平滑过渡到服务器部署的 Milvus。由于 API 和 SDK 的一致性，迁移过程将非常简便。只需更改客户端连接参数，指向服务器部署的 Milvus 实例，其余代码无需大改。
# 从 Milvus Lite 迁移到服务器部署的 Milvus
# 本地连接
client = MilvusClient("./milvus_demo.db")
# 生产环境中连接到服务器部署的 Milvus
client = MilvusClient(uri="http://your-milvus-server:19530", token="your_token")
注意事项：
- 高级特性：在服务器部署中，您可以利用 Milvus 的高级特性，如多种索引类型、分区管理、负载均衡等。
- 性能优化：在服务器环境中，可以进行更多的性能优化配置，以处理更高的并发和更大的数据量。
- 安全配置：服务器部署支持更复杂的安全配置，如认证、授权和 TLS 加密，确保数据和系统的安全。
LangChain Milvus
当然，我很高兴帮助您优化和解释您提供的 Milvus 文档内容。以下是优化后的教案，旨在帮助您更好地理解和使用 Milvus 及其与 LangChain 的集成。
Milvus 与 LangChain 入门教案
课程目标
- 理解 Milvus 的基本概念及其在向量数据库中的作用。
- 学会在本地环境中使用 Milvus Lite 进行向量存储和搜索。
- 掌握 Milvus 与 LangChain 的集成方法。
- 学会创建集合、插入数据、执行相似性搜索和管理向量存储。
- 了解 Milvus Lite 的使用限制及数据迁移方法。
先决条件
- 基本的 Python 编程知识。
- 安装了 Python 3.8 及以上版本。
- 熟悉 Jupyter Notebook 或其他 Python 开发环境（推荐）。
- 基本的命令行操作知识。
所需材料
- 一台运行 Ubuntu >= 20.04、MacOS >= 11.0 或其他支持的操作系统的计算机。
- Python 环境（推荐使用虚拟环境，如
venv或conda）。 - 网络连接（用于安装依赖和下载嵌入模型）。
课程结构
- Milvus 简介
- 环境设置
- 初始化 Milvus 与 Embeddings
- 管理 Milvus 集合
- 执行向量搜索
- 使用检索器进行搜索
- 检索增强生成 (RAG) 的应用
- 数据迁移与管理
- Milvus Lite 使用限制
- 总结与下一步
1. Milvus 简介
Milvus 是一个开源的向量数据库，专为存储、索引和管理由深度神经网络及其他机器学习模型生成的海量嵌入向量而设计。它支持高效的相似性搜索，广泛应用于推荐系统、图像搜索、自然语言处理等领域。
Milvus Lite 是 Milvus 的轻量级版本，内置于 pymilvus 库中，适用于本地开发、原型设计和小规模应用。
2. 环境设置
安装 LangChain-Milvus
为了使用 Milvus 与 LangChain 的集成，您需要安装 langchain-milvus 库。使用以下命令进行安装：
pip install -qU langchain-milvus
安装 LangChain-OpenAI
为了生成向量嵌入，您还需要安装 langchain-openai 库：
pip install -qU langchain-openai
注意：最新版本的
pymilvus已包含 Milvus Lite，适合快速原型开发。如果您处理的数据量较大（如超过一百万条文档），建议在 Docker 或 Kubernetes 上部署更高性能的 Milvus 服务器。
3. 初始化 Milvus 与 Embeddings
设置 OpenAI API 密钥
首先，您需要设置 OpenAI 的 API 密钥，以便生成文本的嵌入向量。可以通过以下方式安全地输入 API 密钥：
import os
import getpass
# 安全地获取 OpenAI API 密钥
os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter your OpenAI API key: ")
导入必要的库并初始化 Embeddings
from langchain_openai import OpenAIEmbeddings
from langchain_milvus import Milvus
# 初始化 OpenAI Embeddings
embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
连接到 Milvus Lite
使用 MilvusClient 连接到本地的 Milvus Lite 实例。数据将存储在指定的本地文件中（例如 milvus_example.db）。
# 定义 Milvus Lite 数据库文件路径
URI = "./milvus_example.db"
# 初始化 Milvus 向量存储
vector_store = Milvus(
embedding_function=embeddings,
connection_args={"uri": URI},
)
注意：如果您有 Milvus 服务器，可以通过指定服务器的 URI 和凭证进行连接，例如：
vector_store = Milvus( embedding_function=embeddings, connection_args={"uri": "http://localhost:19530", "token": "username:password"}, )
4. 管理 Milvus 集合
创建集合
集合（Collection）是 Milvus 中用于存储向量及其相关元数据的基本单位。可以将其视为传统数据库中的表。
from langchain_core.documents import Document
# 创建一个新的集合并插入初始文档
vector_store_saved = Milvus.from_documents(
[Document(page_content="foo!")],
embeddings,
collection_name="langchain_example",
connection_args={"uri": URI},
)
说明：
collection_name：集合的名称，可以根据需要更改。from_documents：从文档列表创建集合并插入初始数据。
插入数据
向 Milvus 集合中插入文档数据。每个文档包含文本内容和元数据。
from uuid import uuid4
from langchain_core.documents import Document
import random
# 创建文档列表
documents = [
Document(
page_content="I had chocolate chip pancakes and scrambled eggs for breakfast this morning.",
metadata={"source": "tweet"},
),
Document(
page_content="The weather forecast for tomorrow is cloudy and overcast, with a high of 62 degrees.",
metadata={"source": "news"},
),
Document(
page_content="Building an exciting new project with LangChain - come check it out!",
metadata={"source": "tweet"},
),
Document(
page_content="Robbers broke into the city bank and stole $1 million in cash.",
metadata={"source": "news"},
),
Document(
page_content="Wow! That was an amazing movie. I can't wait to see it again.",
metadata={"source": "tweet"},
),
Document(
page_content="Is the new iPhone worth the price? Read this review to find out.",
metadata={"source": "website"},
),
Document(
page_content="The top 10 soccer players in the world right now.",
metadata={"source": "website"},
),
Document(
page_content="LangGraph is the best framework for building stateful, agentic applications!",
metadata={"source": "tweet"},
),
Document(
page_content="The stock market is down 500 points today due to fears of a recession.",
metadata={"source": "news"},
),
Document(
page_content="I have a bad feeling I am going to get deleted :(",
metadata={"source": "tweet"},
),
]
# 生成唯一 UUID 作为每个文档的 ID
uuids = [str(uuid4()) for _ in range(len(documents))]
# 添加文档到向量存储
vector_store.add_documents(documents=documents, ids=uuids)
# 输出生成的 UUID
print(uuids)
输出示例：
['b0248595-2a41-4f6b-9c25-3a24c1278bb3',
'fa642726-5329-4495-a072-187e948dd71f',
'9905001c-a4a3-455e-ab94-72d0ed11b476',
'eacc7256-d7fa-4036-b1f7-83d7a4bee0c5',
'7508f7ff-c0c9-49ea-8189-634f8a0244d8',
'2e179609-3ff7-4c6a-9e05-08978903fe26',
'fab1f2ac-43e1-45f9-b81b-fc5d334c6508',
'1206d237-ee3a-484f-baf2-b5ac38eeb314',
'd43cbf9a-a772-4c40-993b-9439065fec01',
'25e667bb-6f09-4574-a368-661069301906']
删除数据
可以通过 ID 或过滤条件删除向量存储中的文档。
# 按 UUID 删除最后一个文档
vector_store.delete(ids=[uuids[-1]])
# 输出删除结果
print(vector_store.delete(ids=[uuids[-1]]))
输出示例：
(insert count: 0, delete count: 1, upsert count: 0, timestamp: 0, success count: 0, err count: 0, cost: 0)
5. 执行向量搜索
相似性搜索
通过相似性搜索，可以找到与查询文本最相似的文档。
# 执行相似性搜索
results = vector_store.similarity_search(
"LangChain provides abstractions to make working with LLMs easy",
k=2,
expr='source == "tweet"',
)
# 输出搜索结果
for res in results:
print(f"* {res.page_content} [{res.metadata}]")
输出示例：
* Building an exciting new project with LangChain - come check it out! [{'pk': '9905001c-a4a3-455e-ab94-72d0ed11b476', 'source': 'tweet'}]
* LangGraph is the best framework for building stateful, agentic applications! [{'pk': '1206d237-ee3a-484f-baf2-b5ac38eeb314', 'source': 'tweet'}]
说明：
k=2：返回最相似的两个文档。expr='source == "tweet"'：仅搜索元数据source为"tweet"的文档。
带分数的相似性搜索
您可以在搜索结果中包含相似度分数，以评估结果的相关性。
# 执行带分数的相似性搜索
results = vector_store.similarity_search_with_score(
"Will it be hot tomorrow?",
k=1,
expr='source == "news"'
)
# 输出带分数的搜索结果
for res, score in results:
print(f"* [SIM={score:3f}] {res.page_content} [{res.metadata}]")
输出示例：
* [SIM=21192.628906] The stock market is down 500 points today due to fears of a recession. [{'pk': '2e179609-3ff7-4c6a-9e05-08978903fe26', 'source': 'news'}]
说明：
similarity_search_with_score：返回每个结果的相似度分数。score：相似度分数，值越高表示越相似（根据距离度量不同，分数的意义可能不同）。
6. 使用检索器进行搜索
检索器（Retriever）可以简化搜索过程，特别是在构建复杂的应用链（Chain）或代理（Agent）时。
将向量存储转换为检索器
# 将向量存储转换为检索器，使用 MMR（最大边缘相关）搜索策略
retriever = vector_store.as_retriever(search_type="mmr", search_kwargs={"k": 1})
# 使用检索器进行搜索
results = retriever.invoke("Stealing from the bank is a crime", filter={"source": "news"})
# 输出检索结果
print(results)
输出示例：
[Document(metadata={'pk': 'eacc7256-d7fa-4036-b1f7-83d7a4bee0c5', 'source': 'news'}, page_content='Robbers broke into the city bank and stole $1 million in cash.')]
说明：
as_retriever：将向量存储转换为检索器，支持不同的搜索策略（如 MMR）。invoke：使用检索器执行搜索，传入查询文本和过滤条件。
7. 检索增强生成 (RAG) 的应用
检索增强生成（Retrieval-Augmented Generation, RAG）结合了向量搜索和生成模型，能够基于外部知识生成更加准确和相关的回答。
使用 Milvus 进行 RAG
- 准备文档：将需要用于生成回答的文档存储在 Milvus 中。
- 生成查询向量：使用嵌入模型将用户的查询转换为向量。
- 执行向量搜索：从 Milvus 中检索与查询向量最相似的文档。
- 生成回答：使用生成模型（如 GPT-4）基于检索到的文档生成回答。
示例：
假设您已经将相关文档存储在 Milvus 中，可以通过以下步骤实现 RAG：
from langchain_core.chains import RetrievalQA
from langchain_core.llms import OpenAI
# 初始化 OpenAI LLM
llm = OpenAI(model="gpt-4")
# 创建 RAG 链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
retriever=vector_store.as_retriever(search_type="mmr", search_kwargs={"k": 2}),
)
# 执行问答
answer = qa_chain.run("How does Milvus enhance AI applications?")
print(answer)
说明：
RetrievalQA：LangChain 提供的问答链，结合了检索和生成模型。as_retriever：检索器用于从 Milvus 中获取相关文档。run：执行问答，输入查询文本，返回生成的回答。
8. 数据迁移与管理
数据持久化
Milvus Lite 将所有数据存储在本地文件中，通过重新连接到相同的数据库文件，可以加载现有数据。
from langchain_milvus import Milvus
# 连接到现有的 Milvus Lite 数据库
vector_store_loaded = Milvus(
embedding_function=embeddings,
connection_args={"uri": "./milvus_example.db"},
collection_name="langchain_example",
)
数据迁移
Milvus Lite 提供了命令行工具，可以将数据导出为 JSON 文件，便于迁移到其他 Milvus 部署（如 Milvus Standalone、Milvus Distributed 或 Zilliz Cloud）。
安装 Bulk Writer
pip install -U "pymilvus[bulk_writer]"
导出数据
milvus-lite dump -d ./milvus_example.db -c langchain_example -p ./data_dir
参数说明：
-d,--db-file：Milvus Lite 数据库文件路径。-c,--collection：需要导出的集合名称。-p,--path：导出文件的存储目录。
说明：
- 导出的数据可以通过 Milvus 的批量插入功能导入到其他 Milvus 实例中，或上传到 Zilliz Cloud 进行数据导入。
9. Milvus Lite 使用限制
Milvus Lite 适用于小规模的向量搜索用例，但在某些功能上存在限制。以下是 Milvus Lite 的主要使用限制：
9.1 集合（Collection）
| 方法 / 参数 | 支持情况 |
|---|---|
create_collection() | 支持，参数有限制 |
collection_name | 支持 |
dimension | 支持 |
primary_field_name | 支持 |
id_type | 支持 |
vector_field_name | 支持 |
metric_type | 支持 |
auto_id | 支持 |
schema | 支持 |
index_params | 支持 |
enable_dynamic_field | 支持 |
num_shards | 不支持 |
partition_key_field | 不支持 |
num_partitions | 不支持 |
consistency_level | 仅支持 Strong |
get_collection_stats() | 支持，获取集合统计信息 |
describe_collection() | 部分参数无效（如 num_shards） |
has_collection() | 支持，检查集合是否存在 |
list_collections() | 支持，列出所有集合 |
drop_collection() | 支持，删除集合 |
rename_collection() | 不支持 |
9.2 字段与模式（Field & Schema）
| 方法 / 参数 | 支持情况 |
|---|---|
create_schema() | 支持，参数有限制 |
auto_id | 支持 |
enable_dynamic_field | 支持 |
primary_field | 支持 |
partition_key_field | 不支持 |
add_field() | 支持，参数有限制 |
field_name | 支持 |
datatype | 支持 |
is_primary | 支持 |
max_length | 支持 |
element_type | 支持 |
max_capacity | 支持 |
dim | 支持 |
is_partition_key | 不支持 |
9.3 插入与搜索（Insert & Search）
| 方法 / 参数 | 支持情况 |
|---|---|
search() | 支持，参数有限制 |
collection_name | 支持 |
data | 支持 |
filter | 支持 |
limit | 支持 |
output_fields | 支持 |
search_params | 支持 |
timeout | 支持 |
partition_names | 不支持 |
anns_field | 支持 |
query() | 支持，参数有限制 |
get() | 支持，参数有限制 |
delete() | 支持，参数有限制 |
insert() | 支持，参数有限制 |
upsert() | 支持，参数有限制 |
9.4 加载与释放（Load & Release）
| 方法 / 参数 | 支持情况 |
|---|---|
load_collection() | 支持 |
release_collection() | 支持 |
get_load_state() | 不支持 |
refresh_load() | 不支持 |
close() | 支持 |
9.5 索引（Index）
| 方法 / 参数 | 支持情况 |
|---|---|
list_indexes() | 支持，列出索引 |
collection_name | 支持 |
field_name | 支持 |
create_index() | 仅支持 FLAT 索引类型 |
index_params | 支持 |
timeout | 支持 |
drop_index() | 支持，删除索引 |
index_name | 支持 |
describe_index() | 支持，描述索引 |
9.6 向量索引类型（Vector Index Types）
Milvus Lite 仅支持 FLAT 索引类型。无论在集合中指定何种索引类型，Milvus Lite 都会使用 FLAT 类型。
9.7 搜索功能（Search Features）
Milvus Lite 支持以下搜索功能：
- 稀疏向量（Sparse Vector）
- 多向量（Multi-vector）
- 混合搜索（Hybrid Search）
9.8 分区与用户管理
- 分区（Partition）：Milvus Lite 不支持分区及相关方法。
- 用户与角色（Users & Roles）：Milvus Lite 不支持用户和角色管理。
- 别名（Alias）：Milvus Lite 不支持别名及相关方法。
10. 总结与下一步
关键要点总结
- Milvus 简介：Milvus 是一个高性能的向量数据库，专为存储和搜索高维向量数据而设计，适用于各种 AI 应用。
- 环境设置：通过安装
langchain-milvus和langchain-openai库，准备好使用 Milvus 与 LangChain 的集成。 - 初始化 Milvus 与 Embeddings：设置 OpenAI API 密钥，初始化嵌入模型，并连接到 Milvus Lite。
- 管理 Milvus 集合：创建集合、插入数据、删除数据等基本操作。
- 执行向量搜索：包括相似性搜索和带分数的相似性搜索。
- 使用检索器进行搜索：简化搜索过程，特别是在复杂应用中。
- RAG 的应用：结合检索和生成模型，实现更智能的问答系统。
- 数据迁移与管理：通过命令行工具导出数据，便于迁移到其他 Milvus 部署。
- Milvus Lite 使用限制：了解 Milvus Lite 的功能限制，适用于小规模应用。
下一步学习建议
- 深入实践：
- 构建一个完整的文本搜索应用，结合自然语言处理（NLP）模型生成向量嵌入。
- 开发一个图像搜索系统，使用图像特征向量进行相似性搜索。
- 探索高级功能：
- 了解不同索引类型的性能和适用场景，如 IVF、HNSW 等。
- 学习分布式部署和集群管理，提升 Milvus 的可扩展性和高可用性。
- 数据迁移与扩展：
- 学习如何将数据从 Milvus Lite 迁移到 Milvus Standalone 或 Milvus Distributed。
- 探索如何在 Docker 或 Kubernetes 上部署 Milvus 以处理更大规模的数据和更高的查询负载。
- 安全与优化：
- 了解 Milvus 的安全配置，如认证、授权和 TLS 加密，确保数据和系统的安全。
- 学习性能优化技巧，提升查询效率和系统响应速度。
- 参与社区和获取支持：
- 加入 Milvus 的官方论坛、Slack 或其他社区渠道，与其他开发者交流经验。
- 阅读官方文档和教程，了解最新的功能和最佳实践。
参考资源
- 官方文档：Milvus 官方文档
- GitHub 仓库：Milvus GitHub
- 社区支持：加入 Milvus 的社区论坛或 Slack 频道，获取帮助和交流经验。
- 教程和示例：Milvus Tutorials
原文地址：https://blog.csdn.net/xnuscd/article/details/144015910
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！