Skip to content

README.md

Latest commit

 

History

History
208 lines (182 loc) · 12.8 KB

README.md

File metadata and controls

208 lines (182 loc) · 12.8 KB
Milvus Logo

Milvus Workshop: From Getting Started to Application

zh

Workshop Objectives:

  • Understand the concept of a vector database and its value in the AI field.
  • Master the installation, basic architecture, and core component functions of Milvus.
  • Be able to use the Milvus Python SDK for basic operations such as Collection management, data insertion, vector search, and data query.
  • Practice the role and implementation of Milvus in practical applications like image search, RAG (Retrieval-Augmented Generation), and AI Agents.

Environment Preparation (Participants need to complete this in advance or guidance will be provided at the beginning of the workshop):

  • Install Docker and Docker Compose.
  • Install Python 3.9+.
  • Install the required Python libraries: pymilvus, torch (or transformers for generating vectors), langchain, langgraph, etc.
  • Install Jupyter Notebook or JupyterLab.

Part 1: Exploring Milvus - Installation, Concepts, and Core Components

  • 1.1 Overview of Milvus Vector Database

    • What is a Vector Embedding?
    • Why do we need a vector database? (Comparison with traditional databases, the need for ANN search)
    • What is Milvus? (Positioning, core features, advantages, community overview)
    • Analysis of Milvus Core Concepts
      • Collection: Analogous to a table in a relational database.
      • Schema: Defines the structure of a Collection (Fields: Primary Key, Vector Field, Scalar Fields).
      • Entity: A row of data, containing an ID, a vector, and scalar attributes.
      • Index: Key to accelerating vector search, introduction to different index types (e.g., FLAT, IVF_FLAT, HNSW).
      • Search/Query: ANN search vs. filtered queries based on scalar fields.
      • Consistency Level: The impact of different levels on data visibility.
      • Partition: Logical grouping of data within a Collection (to improve query efficiency), optimizing data management and query performance.
    • Milvus Deployment: Comparison of Lite vs. Standalone vs. Cluster modes (The workshop will use Standalone).

  • 1.2 Hands-on Milvus Installation

    • Introduction to different installation methods (Docker Compose, Kubernetes, Cloud Services).
    • Hands-on: Zilliz Cloud Free Tier
      • Register for a Zilliz Cloud account.
      • Create a Milvus instance.
      • Connect to the Milvus instance (using the Python SDK or Milvus CLI).
    • Hands-on: Quick Local Installation of Milvus Standalone using Docker Compose (if the environment permits)
      • Download the configuration file (milvus-standalone.yaml or milvus-cluster.yaml).
      • Start with the docker compose up -d command.
      • Explain the key services and ports in the Docker Compose file.
    • Verify Installation:
      • Check the Docker container status.
      • Overview of Milvus SDKs (Python, Go, Java, Node.js, C# - this workshop focuses on Python).
      • Test the connection using milvus_cli or the Python SDK.
      • Introduction to the WebUI: A graphical management tool.
      • Introduction to Attu: Milvus's visualization management tool (installation and basic usage).

  • 1.3 Analysis of Milvus Core Architecture and Components

    • Overview of Milvus's distributed architecture (decoupled design).
    • Detailed explanation of core component functions:
      • Proxy: Request entry point, load balancing.
      • Root Coord: Cluster brain, manages topology and tasks.
      • Data Coord: Data ingestion coordinator, manages data segments.
      • Query Coord: Query coordinator, manages query nodes and index loading.
      • Index Coord: Index coordinator, manages index-building tasks.
      • Data Node: Ingestion node, handles data writing and persistence.
      • Query Node: Query node, loads data and indexes, executes searches/queries.
      • Index Node: Index-building node, executes index-building tasks.
    • Architectural Optimizations in Milvus 2.6
      • Streaming Node: Real-time data stream processing.

  • 1.4 Milvus Access Control RBAC

    • Why is access control important when using Milvus?
    • What is RBAC in Milvus?
    • How RBAC works in Milvus.
    • How to configure access control via RBAC in Milvus.
    • Example: Access control design for a Milvus-driven RAG system.
    • Quick tips: How to operate access control securely in production.
    • Q&A & Summary

Part 2: Basic Milvus Operations - Using the Python SDK

  • 2.1 Connecting to Milvus and Managing Collections

    • Concept: Collection
    • Hands-on: Defining a Collection Schema.
      • Concept of Fields (Primary Key Field, Vector Field, Scalar Field).
      • Data types (Int, Float, String, Array, JSON, FloatVector).
      • How to define a Primary Key.
      • How to define a Vector Field (Dimension).
      • How to define an auto-ID.
    • Hands-on: Creating, deleting, and viewing a Collection.
    • Hands-on: Loading and releasing a Collection.
    • Hands-on Exercise 1: Create a simple Collection with several Scalar Fields and one Vector Field.

  • 2.2 Data Insertion and Management

    • Concept: Entity.
    • Concept: Partition.
    • Hands-on: Preparing data for insertion.
    • Hands-on: Inserting data into a Collection (or a specific Partition).
      • Explain data format requirements.
      • Techniques for batch insertion.
    • Hands-on: Deleting data (by ID or filter conditions).
    • Hands-on Exercise 2: Insert a batch of mock data into the previously created Collection and try deleting some of it.

  • 2.3 Building and Managing Indexes

    • Concept: Index
    • Core Concept: Approximate Nearest Neighbor Search (ANNS).
    • Brief introduction to common vector index types and their use cases:
      • FLAT: Accurate but slow.
      • IVF_FLAT: Clustering + exact search.
      • IVF_SQ8: Clustering + quantization (compression).
      • IVF_PQ: Clustering + product quantization.
      • HNSW: Graph-based index (high performance, commonly used).
    • Introduction to Distance Metrics: Euclidean distance (L2), Inner Product (IP), Cosine Similarity.
    • Hands-on: Creating an index for a Vector Field.
      • Selecting the index type and parameters (e.g., nlist for IVF, M, efConstruction for HNSW).
    • Hands-on: Checking the index status.
    • Hands-on Exercise 3: Create an HNSW index for the Vector Field in your Collection.

  • 2.4 Vector Similarity Search, Query, and Hybrid Search

    • Concept: Vector Search.
    • Hands-on: Executing a vector search.
      • Prepare search vectors.
      • Set search parameters (e.g., anns_field, param, limit, output_fields).
      • Explain the search results (id, distance, fields).
    • Concept: Data Query.
    • Hands-on: Executing a data query.
    • Concept: Hybrid Search. - Combining vector similarity and Sparse-BM25 filtering conditions for searching.
    • Hands-on: Executing a hybrid search.
    • Hands-on Exercise 4: Perform a simple vector search, a query based on a Scalar Field, and a hybrid search.
    • Q&A & Summary

Part 3: Milvus Application Practice - Image Search, RAG, and Agent Use Cases

  • 3.1 Applying Milvus in Image Search

    • Process: Image Loading -> Image Vectorization (Embedding) -> Storage -> Retrieval.
    • Role of Milvus in Image Search: Store image feature vectors to enable Image-to-Image Search or Text-to-Image Search.
    • Case Study / Code Walkthrough:
      • Use a pre-trained model (like CLIP, ResNet, etc.) to vectorize an image dataset.
      • Insert image paths/IDs and vectors into Milvus.
      • Input an image or a text description, and generate a vector using the same model.
      • Perform a vector search in Milvus to return the IDs or paths of similar images.
    • Hands-on Exercise 1: Perform a text-to-image search on a small number of images using cross-modal search (CLIP).

  • 3.2 Applying Milvus in RAG (Retrieval-Augmented Generation)

    • RAG Process Review: Document Loading -> Chunking -> Vectorization (Embedding) -> Storage -> Retrieval -> Generation.
    • Role of Milvus in RAG: Acts as an external knowledge base to store text chunks and their vectors for fast retrieval of relevant text.
    • Case Study / Code Walkthrough:
      • Use LangChain for document processing and vectorization (using Sentence Transformers, OpenAI embeddings, etc.).
      • Insert vectorized text chunks and metadata into Milvus.
      • Receive a user question and vectorize it.
      • Use Milvus to perform a vector search and retrieve relevant text chunks.
      • Feed the retrieved text chunks as context to an LLM to generate an answer.
    • Discussion: How to optimize retrieval effectiveness in RAG (Chunk size, choice of embedding model, use of hybrid search).
    • Hands-on Exercise 2: Try modifying the search parameters and observe the changes in the retrieval results.
    • [TODO]: Add more RAG use cases or RAG best practices.

  • 3.3 Applying Milvus in AI Agents

    • AI Agent Architecture Overview: Planning, Memory, Tools.
    • Role of Milvus in Agents:
      • External Knowledge Base: Stores external information that the Agent needs to query (similar to RAG).
      • Memory: Stores the Agent's dialogue history, learned experiences, planning steps, etc. (in vector form).
    • Case Study / Code Walkthrough:
      • Implement an Agent using LangGraph.
      • The Agent identifies the need for external information -> converts the query into a vector -> searches for relevant knowledge in Milvus -> obtains information -> continues planning.
      • The Agent stores conversation fragment vectors -> searches for similar history at the start of a new conversation -> recalls relevant memories.
    • Discussion: How Milvus empowers Agents to perform tasks more intelligently.
    • Hands-on Exercise 3: Hands-on with an AI Agent Demo.

  • 3.4 Overview of Milvus Ecosystem Features

    • Brief introduction to Milvus ecosystem tools (data synchronization VTS, Milvus CDC, Milvus Backup, VectorDBBench, DeepSearcher, MCP).
    • Future applications of Milvus in other fields (recommendation systems, anomaly detection, etc.).
    • Recommended learning resources (official documentation, community, GitHub).

Part 4: Advanced Milvus Practice

  • 4.1 Hands-on Milvus Observability and Operations
    • Observability Deployment: A complete observability solution based on Prometheus + Loki + Jaeger + Grafana.
    • Core Monitoring Metrics: In-depth understanding of Milvus's key performance indicators and health status.
  • 4.2 Hands-on Benchmarking with VectorDBBench
    • Introduction to VectorDBBench
    • Deployment and Installation
    • Web Interface and Features
    • Benchmarking with Default Datasets
    • Benchmarking with Custom Datasets
    • Result Analysis
  • 4.3 Milvus Performance Tuning
    • Summary of Common Issues from the Milvus Community
      • Memory: Saving as much as possible.
      • Insertion: Smooth data ingestion is the first step to a good developer experience.
      • Configuration: Half of all usage problems are configuration problems.
    • Optimizing Milvus Performance
      • Reasonably estimate metrics like data volume, number of tables, and QPS.
      • Choose appropriate index types and parameters.
      • Choose wisely between streaming insertion and bulk import.
      • Use features like scalar filtering and deletion with caution.
      • Deploy monitoring and observe the cluster status.
      • Some common parameter adjustments.
    • Accelerating Milvus in Practice: From Resource Allocation to Parameter Tuning
      • Physical resource configuration.
      • Parameter tuning related to vector indexes.
  • 4.4 Milvus Upgrade
    • Milvus 2.5 → 2.6 upgrade