Milvus Documentation

https://milvus.io/docs
Admin
Milvus is an open-source vector database designed for efficient similarity search and AI...
Tokens:789,682
Snippets:7,508
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install and start Milvus with Docker

Source: https://milvus.io/docs/install_standalone-docker.md

Downloads the standalone installation script and executes it to start the Milvus Docker container.

```bash
# Download the installation script
$ curl -sfL https://raw.githubusercontent.com/milvus-io/milvus/master/scripts/standalone_embed.sh -o standalone_embed.sh

# Start the Docker container
$ bash standalone_embed.sh start
```

--------------------------------

### Install and Start Milvus with Docker Compose

Source: https://milvus.io/docs/install_standalone-docker-compose.md

Downloads the official configuration file and initializes the Milvus standalone containers.

```bash
# Download the configuration file
$ wget https://github.com/milvus-io/milvus/releases/download/v3.0.0/milvus-standalone-docker-compose.yml -O docker-compose.yml

# Start Milvus
$ sudo docker compose up -d

Creating milvus-etcd  ... done
Creating milvus-minio ... done
Creating milvus-standalone ... done
```

--------------------------------

### Download and Run Milvus Verification

Source: https://milvus.io/docs/eks.md

Commands to fetch the hello_milvus.py example and execute it to verify the installation.

```bash
wget https://raw.githubusercontent.com/milvus-io/pymilvus/master/examples/hello_milvus.py
```

```bash
python3 hello_milvus.py
```

--------------------------------

### Install Dependencies

Source: https://milvus.io/docs/rag_with_milvus_and_unstructured.md

Install the necessary libraries for Unstructured, Milvus, and OpenAI.

```bash
$ pip install -qU "unstructured[pdf]" pymilvus milvus-lite openai
```

--------------------------------

### Switch Docker Daemon

Source: https://milvus.io/docs/install_standalone-windows.md

Navigate to the Docker installation directory and execute the switch command to start the Docker Daemon.

```cmd
C:\>cd "C:\Program Files\Docker\Docker"
C:\Program Files\Docker\Docker>\.\DockerCli.exe -SwitchDaemon
Switching to windows engine: Post "http://ipc/engine/switch": open \\.\pipe\dockerBackendApiServer: The system cannot find the file specified.
```

--------------------------------

### Install dependencies

Source: https://milvus.io/docs/build_RAG_with_milvus_and_feast.md

Install the necessary Feast and OpenAI libraries.

```bash
$ pip install 'feast[milvus]' openai -U -q
```

--------------------------------

### List users output example

Source: https://milvus.io/docs/users_and_roles.md

Example output returned when listing users.

```text
['root', 'user_1']
```

--------------------------------

### Install Dependencies

Source: https://milvus.io/docs/multimodal_rag_with_milvus.md

Install the necessary Python packages and the FlagEmbedding repository.

```bash
$ pip install --upgrade pymilvus openai datasets opencv-python timm einops ftfy peft tqdm
```

```bash
$ git clone https://github.com/FlagOpen/FlagEmbedding.git
$ pip install -e FlagEmbedding
```

--------------------------------

### Install Dependencies

Source: https://milvus.io/docs/agentic_rag_with_milvus_and_langgraph.md

Install the required LangChain, LangGraph, and Milvus libraries.

```bash
$ pip install --upgrade langchain langchain-core langchain-community langchain-text-splitters langgraph langchain-milvus milvus-lite langchain-openai bs4
```

--------------------------------

### Install Dependencies

Source: https://milvus.io/docs/build_RAG_with_milvus_and_docling.md

Install the necessary libraries for Milvus, Docling, and OpenAI integration.

```bash
$ pip install --upgrade pymilvus milvus-lite docling openai
```

--------------------------------

### Install Dependencies

Source: https://milvus.io/docs/evaluation_with_phoenix.md

Install the required libraries including pymilvus, openai, and arize-phoenix.

```bash
$ pip install --upgrade pymilvus milvus-lite openai requests tqdm pandas "arize-phoenix>=4.29.0" nest_asyncio
```

--------------------------------

### Install Make Utility

Source: https://milvus.io/docs/use_milvus_in_private_gpt.md

Install the make utility required for running project scripts.

```bash
$ brew install make
```

```bash
$ choco install make
```

--------------------------------

### Install required libraries

Source: https://milvus.io/docs/quickstart_mem0_with_milvus.md

Install the necessary packages for Mem0 and Milvus integration.

```bash
$ pip install mem0ai pymilvus milvus-lite
```

--------------------------------

### Create partition example

Source: https://milvus.io/docs/cli_commands.md

Shows the command to create a partition with a specified name and description.

```bash
milvus_cli > create partition -c car -p new_partition -d test_add_partition
```

--------------------------------

### Providing N-Shot Examples for LangExtract

Source: https://milvus.io/docs/langextract_milvus_demo.md

Defines a list of example data objects to guide the model and iterates through documents to perform extraction.

```python
# Provide examples to guide the model - n-shot examples for movie descriptions
# Unify attribute keys to ensure consistency in extraction results
examples = [
    lx.data.ExampleData(
        text="A space marine battles alien creatures on a distant planet. The sci-fi action movie features futuristic weapons and intense combat scenes.",
        extractions=[
            lx.data.Extraction(
                extraction_class="genre",
                extraction_text="sci-fi action",
                attributes={"primary_genre": "sci-fi", "secondary_genre": "action"},
            ),
            lx.data.Extraction(
                extraction_class="character",
                extraction_text="space marine",
                attributes={"role": "protagonist", "type": "military"},
            ),
            lx.data.Extraction(
                extraction_class="theme",
                extraction_text="battles alien creatures",
                attributes={"theme_type": "conflict", "setting": "space"},
            ),
        ],
    ),
    lx.data.ExampleData(
        text="A detective investigates supernatural murders in Victorian London. The horror thriller film combines period drama with paranormal elements.",
        extractions=[
            lx.data.Extraction(
                extraction_class="genre",
                extraction_text="horror thriller",
                attributes={"primary_genre": "horror", "secondary_genre": "thriller"},
            ),
            lx.data.Extraction(
                extraction_class="character",
                extraction_text="detective",
                attributes={"role": "protagonist", "type": "detective"},
            ),
            lx.data.Extraction(
                extraction_class="theme",
                extraction_text="supernatural murders",
                attributes={"theme_type": "investigation", "setting": "victorian"},
            ),
        ],
    ),
    lx.data.ExampleData(
        text="Two friends embark on a road trip adventure across America. The comedy drama explores friendship and self-discovery through humorous situations.",
        extractions=[
            lx.data.Extraction(
                extraction_class="genre",
                extraction_text="comedy drama",
                attributes={"primary_genre": "comedy", "secondary_genre": "drama"},
            ),
            lx.data.Extraction(
                extraction_class="character",
                extraction_text="two friends",
                attributes={"role": "protagonist", "type": "friends"},
            ),
            lx.data.Extraction(
                extraction_class="theme",
                extraction_text="friendship and self-discovery",
                attributes={"theme_type": "personal_growth", "setting": "america"},
            ),
        ],
    ),
]

# Extract from each document
extraction_results = []
for doc in sample_documents:
    result = lx.extract(
        text_or_documents=doc,
        prompt_description=prompt,
        examples=examples,
        model_id="gemini-2.0-flash",
    )
    extraction_results.append(result)
    print(f"Successfully extracted from document: {doc[:50]}...")

print(f"Completed tag extraction, processed {len(extraction_results)} documents")
```

--------------------------------

### Initialize clients

Source: https://milvus.io/docs/build_RAG_with_milvus_and_exa.md

Set up the OpenAI, Exa, and Milvus clients for the application.

```python
import json
from openai import OpenAI
from pymilvus import MilvusClient, DataType
from exa_py import Exa

llm = OpenAI()
exa = Exa(api_key=os.environ["EXA_API_KEY"])
milvus = MilvusClient(uri="./milvus_exa_demo.db")

EMBED_MODEL = "text-embedding-3-small"
EMBED_DIM = 1536
COLLECTION = "private_kb"
```

--------------------------------

### Create and List Partitions

Source: https://milvus.io/docs/manage-partitions.md

Examples for creating a partition and listing all partitions in a collection across multiple programming languages.

```python
client.create_partition(
    collection_name="my_collection",
    partition_name="partitionA"
)

res = client.list_partitions(
    collection_name="my_collection"
)

print(res)

# Output
#
# ["_default", "partitionA"]
```

```java
import io.milvus.v2.service.partition.request.CreatePartitionReq;

CreatePartitionReq createPartitionReq = CreatePartitionReq.builder()
        .collectionName("my_collection")
        .partitionName("partitionA")
        .build();

client.createPartition(createPartitionReq);

ListPartitionsReq listPartitionsReq = ListPartitionsReq.builder()
        .collectionName("my_collection")
        .build();

List<String> partitionNames = client.listPartitions(listPartitionsReq);
System.out.println(partitionNames);

// Output:
// [_default, partitionA]
```

```javascript
await client.createPartition({
    collection_name: "my_collection",
    partition_name: "partitionA"
})

res = await client.listPartitions({
    collection_name: "my_collection"
})

console.log(res)

// Output
// ["_default", "partitionA"]
```

```go
import (
    "fmt"
    
    client "github.com/milvus-io/milvus/client/v2/milvusclient"
)

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

err = client.CreatePartition(ctx, milvusclient.NewCreatePartitionOption("my_collection", "partitionA"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

partitionNames, err := client.ListPartitions(ctx, milvusclient.NewListPartitionOption("my_collection"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println(partitionNames)
// Output
// ["_default", "partitionA"]
```

```bash
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "partitionName": "partitionA"
}'

# {
#     "code": 0,
#     "data": {}
# }

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/list" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection"
}'

# {
#     "code": 0,
#     "data": [
#         "_default",
#         "partitionA"
#     ]
# }
```

--------------------------------

### Start the application

Source: https://milvus.io/docs/knowledge_table_with_milvus.md

Launch the Knowledge Table services using Docker Compose.

```bash
$ docker compose up -d --build
```

--------------------------------

### Example Process Output

Source: https://milvus.io/docs/coordinator_ha.md

Sample output showing multiple coordinator processes running.

```text
> ps aux|grep milvus
root        12813   0.7 0.2 410709648   82432   ??  S   5:18PM  0:33.28 ./bin/milvus run rootcoord
root        12816   0.5 0.2 409487968   62352   ??  S   5:18PM  0:22.69 ./bin/milvus run proxy
root        17739   0.1 0.3 410289872   91792 s003  SN  6:01PM  0:00.30 ./bin/milvus run rootcoord
...

  
```

--------------------------------

### Prepare Environment Configuration

Source: https://milvus.io/docs/dify_with_milvus.md

Navigate to the docker directory and initialize the environment file.

```bash
cd dify/docker
```

```bash
cp .env.example .env
```

--------------------------------

### Configure Regex Filter in Milvus

Source: https://milvus.io/docs/regex-filter.md

Examples of defining analyzer parameters with a regex filter to exclude tokens starting with 'test'.

```python
analyzer_params = {
    "tokenizer": "standard",
    "filter": [{
        "type": "regex",
        "expr": "^(?!test)" # keep tokens that do NOT start with "test"
    }]
}
```

```java
Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "standard");
analyzerParams.put("filter",
        Arrays.asList(new HashMap<String, Object>() {{
                    put("type", "regex");
                    put("expr", "^(?!test)");
                }})
);
```

```javascript
// node
```

```go
analyzerParams = map[string]any{"tokenizer": "standard",
        "filter": []any{map[string]any{
            "type": "regex",
            "expr": "^(?!test)",
        }}}
```

```curl
# curl
```

--------------------------------

### Example Entity Data Structure

Source: https://milvus.io/docs/get-and-scalar-query.md

A JSON array representing entities with id, vector, and color fields used for Get operations.

```json
[
        {"id": 0, "vector": [0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592], "color": "pink_8682"},
        {"id": 1, "vector": [0.19886812562848388, 0.06023560599112088, 0.6976963061752597, 0.2614474506242501, 0.838729485096104], "color": "red_7025"},
        {"id": 2, "vector": [0.43742130801983836, -0.5597502546264526, 0.6457887650909682, 0.7894058910881185, 0.20785793220625592], "color": "orange_6781"},
        {"id": 3, "vector": [0.3172005263489739, 0.9719044792798428, -0.36981146090600725, -0.4860894583077995, 0.95791889146345], "color": "pink_9298"},
        {"id": 4, "vector": [0.4452349528804562, -0.8757026943054742, 0.8220779437047674, 0.46406290649483184, 0.30337481143159106], "color": "red_4794"},
        {"id": 5, "vector": [0.985825131989184, -0.8144651566660419, 0.6299267002202009, 0.1206906911183383, -0.1446277761879955], "color": "yellow_4222"},
        {"id": 6, "vector": [0.8371977790571115, -0.015764369584852833, -0.31062937026679327, -0.562666951622192, -0.8984947637863987], "color": "red_9392"},
        {"id": 7, "vector": [-0.33445148015177995, -0.2567135004164067, 0.8987539745369246, 0.9402995886420709, 0.5378064918413052], "color": "grey_8510"},
        {"id": 8, "vector": [0.39524717779832685, 0.4000257286739164, -0.5890507376891594, -0.8650502298996872, -0.6140360785406336], "color": "white_9381"},
        {"id": 9, "vector": [0.5718280481994695, 0.24070317428066512, -0.3737913482606834, -0.06726932177492717, -0.6980531615588608], "color": "purple_4976"}
]
```

--------------------------------

### Prepare Example Documents

Source: https://milvus.io/docs/full_text_search_with_langchain.md

Create a list of LangChain Document objects with associated metadata for indexing.

```python
from langchain_core.documents import Document

docs = [
    Document(page_content="I like this apple", metadata={"category": "fruit"}),
    Document(page_content="I like swimming", metadata={"category": "sport"}),
    Document(page_content="I like dogs", metadata={"category": "pets"}),
]
```

--------------------------------

### Install Milvus on DEB-based Systems

Source: https://milvus.io/docs/install_standalone-binary.md

Use apt to install the DEB package and verify the installation.

```bash
apt install -y  ./milvus_3.0.0-1_amd64.deb
dpkg -l | grep milvus
```

--------------------------------

### Initialize and Launch Agent Services

Source: https://milvus.io/docs/llama_agents_metadata.md

Sets up the LocalLauncher with defined services and executes a query.

```python
## Define Launcher
launcher = LocalLauncher(
    [agent_server_1, tool_service],
    control_plane,
    message_queue,
)
```

```python
query_str = "What are the risk factors for Uber?"
result = launcher.launch_single(query_str)
```

--------------------------------

### Install Milvus on RPM-based Systems

Source: https://milvus.io/docs/install_standalone-binary.md

Use yum to install the RPM package and verify the installation.

```bash
yum install -y ./milvus_3.0.0-1_amd64.rpm
rpm -qa| grep milvus
```

--------------------------------

### Verify OpenSSL Installation

Source: https://milvus.io/docs/tls.md

Check if OpenSSL is installed on the system.

```bash
openssl version

  
```

--------------------------------

### Create Project Directory

Source: https://milvus.io/docs/video_search_with_twelvelabs_and_milvus.md

Initialize the project folder structure.

```bash
mkdir video-search-tutorial
cd video-search-tutorial
```

--------------------------------

### Install PyTorch for CPU

Source: https://milvus.io/docs/funnel_search_with_matryoshka.md

Install the CPU-only version of PyTorch.

```bash
$ pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
```

--------------------------------

### Prepare Sample Documents

Source: https://milvus.io/docs/milvus_hybrid_search_retriever.md

Initialize a list of Document objects with content and metadata for testing retrieval.

```python
from langchain_core.documents import Document

docs = [
    Document(
        page_content="In 'The Whispering Walls' by Ava Moreno, a young journalist named Sophia uncovers a decades-old conspiracy hidden within the crumbling walls of an ancient mansion, where the whispers of the past threaten to destroy her own sanity.",
        metadata={"category": "Mystery"},
    ),
    Document(
        page_content="In 'The Last Refuge' by Ethan Blackwood, a group of survivors must band together to escape a post-apocalyptic wasteland, where the last remnants of humanity cling to life in a desperate bid for survival.",
        metadata={"category": "Post-Apocalyptic"},
    ),
    Document(
        page_content="In 'The Memory Thief' by Lila Rose, a charismatic thief with the ability to steal and manipulate memories is hired by a mysterious client to pull off a daring heist, but soon finds themselves trapped in a web of deceit and betrayal.",
        metadata={"category": "Heist/Thriller"},
    ),
    Document(
        page_content="In 'The City of Echoes' by Julian Saint Clair, a brilliant detective must navigate a labyrinthine metropolis where time is currency, and the rich can live forever, but at a terrible cost to the poor.",
        metadata={"category": "Science Fiction"},
    ),
    Document(
        page_content="In 'The Starlight Serenade' by Ruby Flynn, a shy astronomer discovers a mysterious melody emanating from a distant star, which leads her on a journey to uncover the secrets of the universe and her own heart.",
        metadata={"category": "Science Fiction/Romance"},
    ),
    Document(
        page_content="In 'The Shadow Weaver' by Piper Redding, a young orphan discovers she has the ability to weave powerful illusions, but soon finds herself at the center of a deadly game of cat and mouse between rival factions vying for control of the mystical arts.",
        metadata={"category": "Fantasy"},
    ),
    Document(
        page_content="In 'The Lost Expedition' by Caspian Grey, a team of explorers ventures into the heart of the Amazon rainforest in search of a lost city, but soon finds themselves hunted by a ruthless treasure hunter and the treacherous jungle itself.",
        metadata={"category": "Adventure"},
    ),
    Document(
        page_content="In 'The Clockwork Kingdom' by Augusta Wynter, a brilliant inventor discovers a hidden world of clockwork machines and ancient magic, where a rebellion is brewing against the tyrannical ruler of the land.",
        metadata={"category": "Steampunk/Fantasy"},
    ),
    Document(
        page_content="In 'The Phantom Pilgrim' by Rowan Welles, a charismatic smuggler is hired by a mysterious organization to transport a valuable artifact across a war-torn continent, but soon finds themselves pursued by deadly assassins and rival factions.",
        metadata={"category": "Adventure/Thriller"},
    ),
    Document(
        page_content="In 'The Dreamwalker's Journey' by Lyra Snow, a young dreamwalker discovers she has the ability to enter people's dreams, but soon finds herself trapped in a surreal world of nightmares and illusions, where the boundaries between reality and fantasy blur.",
        metadata={"category": "Fantasy"},
    ),
]
```

--------------------------------

### Install WSL 2 on Windows

Source: https://milvus.io/docs/install_standalone-windows.md

Command to initialize the WSL 2 environment.

```bash
C:\>wsl --install
Ubuntu already installed.
Starting Ubuntu...
```

--------------------------------

### Install Dependencies

Source: https://milvus.io/docs/RAG_with_pii_and_milvus.md

Install the required Python packages for the project.

```bash
$ pip install --upgrade pymilvus openai requests tqdm dataset
```

--------------------------------

### Install vLLM and Initialize Environment

Source: https://milvus.io/docs/milvus_rag_with_vllm.md

Commands to set up the conda environment, install dependencies, and verify GPU status.

```bash
# (Recommended) Create a new conda environment.
conda create -n myenv python=3.11 -y
conda activate myenv


# Install vLLM with CUDA 12.1.
pip install -U vllm transformers torch


import vllm, torch
from vllm import LLM, SamplingParams


# Clear the GPU memory cache.
torch.cuda.empty_cache()


# Check the GPU.
!nvidia-smi
```

--------------------------------

### Install Dependencies

Source: https://milvus.io/docs/search-with-embedding-lists.md

Install the necessary libraries for ColPali and Milvus integration.

```bash
pip install --upgrade huggingface-hub transformers datasets pymilvus 'colpali-engine>=0.3.0,<0.4.0'
```

--------------------------------

### Install Milvus Lite and View Help

Source: https://milvus.io/docs/milvus_lite.md

Install the necessary package and display the help menu for the milvus-lite command-line tool.

```bash
# Install
pip install -U "pymilvus[bulk_writer]"

milvus-lite dump -h

usage: milvus-lite dump [-h] [-d DB_FILE] [-c COLLECTION] [-p PATH]

optional arguments:
  -h, --help            show this help message and exit
  -d DB_FILE, --db-file DB_FILE
                        milvus lite db file
  -c COLLECTION, --collection COLLECTION
                        collection that need to be dumped
  -p PATH, --path PATH  dump file storage dir
```

--------------------------------

### Install and Initialize Milvus Lite

Source: https://milvus.io/docs/install-overview.md

Install the Python SDK and initialize a local file-based vector database instance.

```bash
pip install pymilvus
```

```python
MilvusClient("./demo.db")
```

--------------------------------

### Prepare Data and Imports

Source: https://milvus.io/docs/full_text_search_with_milvus_and_haystack.md

Import necessary Haystack and Milvus components and initialize sample documents.

```python
from haystack import Pipeline
from haystack.components.embedders import OpenAIDocumentEmbedder, OpenAITextEmbedder
from haystack.components.writers import DocumentWriter
from haystack.utils import Secret
from milvus_haystack import MilvusDocumentStore, MilvusSparseEmbeddingRetriever
from haystack.document_stores.types import DuplicatePolicy
from milvus_haystack.function import BM25BuiltInFunction
from milvus_haystack import MilvusDocumentStore
from milvus_haystack.milvus_embedding_retriever import MilvusHybridRetriever

from haystack.utils import Secret
from haystack.components.builders import PromptBuilder
from haystack.components.generators import OpenAIGenerator
from haystack import Document

documents = [
    Document(content="Alice likes this apple", meta={"category": "fruit"}),
    Document(content="Bob likes swimming", meta={"category": "sport"}),
    Document(content="Charlie likes white dogs", meta={"category": "pets"}),
]
```

--------------------------------

### Install Langflow

Source: https://milvus.io/docs/rag_with_langflow.md

Install or upgrade the Langflow package using pip.

```bash
$ python -m pip install langflow -U
```

--------------------------------

### Install dependencies

Source: https://milvus.io/docs/llamaindex_milvus_async.md

Install the required packages for LlamaIndex and Milvus integration.

```bash
$ pip install -U pymilvus llama-index-vector-stores-milvus llama-index nest-asyncio
```

--------------------------------

### Start LLM Server

Source: https://milvus.io/docs/build_rag_on_arm.md

Launch the server to provide an OpenAI-compatible API, and verify it is listening.

```bash
$ ./llama-server -m dolphin-2.9.4-llama3.1-8b-Q4_0_8_8.gguf -n 2048 -t 64 -c 65536  --port 8080
```

```text
'main: server is listening on 127.0.0.1:8080 - starting the main loop
```

--------------------------------

### Initialize Vector Store and Add Documents

Source: https://milvus.io/docs/llamaindex_milvus_async.md

Setup the vector store and populate it with nodes before performing search operations.

```python
vector_store = init_vector_store()
node_list = produce_nodes(num_adding=1000)
inserted_ids = vector_store.add(node_list)
```

```text
2025-01-24 20:08:57,982 [DEBUG][_create_connection]: Created new connection using: 351dc7ea4fb14d4386cfab02621ab7d1 (async_milvus_client.py:600)
```

--------------------------------

### Install Dependencies

Source: https://milvus.io/docs/integrate_with_llamaindex.md

Commands to install the required pymilvus and LlamaIndex packages.

```bash
$ pip install pymilvus>=2.4.2 milvus-lite
```

```bash
$ pip install llama-index-vector-stores-milvus
```

```bash
$ pip install llama-index
```

--------------------------------

### Install Dependencies

Source: https://milvus.io/docs/integrate_with_camel.md

Install the required Python packages for CAMEL and Milvus.

```bash
$ pip install -U "camel-ai[all]" pymilvus milvus-lite
```

--------------------------------

### List roles output example

Source: https://milvus.io/docs/users_and_roles.md

Example output showing the default admin role and a newly created role.

```text
['admin', 'role_a']
```

--------------------------------

### Initialize Milvus Client and Environment

Source: https://milvus.io/docs/tutorial-implement-a-time-based-ranking-in-milvus.md

Sets up the necessary imports and establishes a connection to the Milvus server, while cleaning up any existing collections.

```python
import datetime
import matplotlib.pyplot as plt
import numpy as np
from pymilvus import (
    MilvusClient,
    DataType,
    Function,
    FunctionType,
    AnnSearchRequest,
)

# Create connection to Milvus
milvus_client = MilvusClient("http://localhost:19530")

# Define collection name
collection_name = "news_articles_tutorial"

# Clean up any existing collection with the same name
milvus_client.drop_collection(collection_name)
```

--------------------------------

### Install Dependencies

Source: https://milvus.io/docs/install-pymilvus.md

Install required dependencies for PyMilvus using pip.

```bash
pip3 install protobuf==3.20.0
```

```bash
pip3 install grpcio-tools
```

--------------------------------

### Install Dependencies

Source: https://milvus.io/docs/build-rag-with-milvus.md

Install the necessary Python packages for the RAG pipeline.

```bash
$ pip install --upgrade pymilvus openai requests tqdm
```

--------------------------------

### List specific component configuration

Source: https://milvus.io/docs/birdwatcher_usage_guides.md

Demonstrates how to visit a specific component to list its configuration.

```text
Milvus(by-dev) > show session
Session:datacoord, ServerID: 3, Version: 2.2.11, Address: 10.244.0.8:13333
Session:datanode, ServerID: 6, Version: 2.2.11, Address: 10.244.0.8:21124
Session:indexcoord, ServerID: 4, Version: 2.2.11, Address: 10.244.0.8:31000
Session:indexnode, ServerID: 5, Version: 2.2.11, Address: 10.244.0.8:21121
Session:proxy, ServerID: 8, Version: 2.2.11, Address: 10.244.0.8:19529
Session:querycoord, ServerID: 7, Version: 2.2.11, Address: 10.244.0.8:19531
Session:querynode, ServerID: 2, Version: 2.2.11, Address: 10.244.0.8:21123
Session:rootcoord, ServerID: 1, Version: 2.2.11, Address: 10.244.0.8:53100

Milvus(by-dev) > visit querycoord 7
QueryCoord-7(10.244.0.8:19531) > configuration
Key: querycoord.enableactivestandby, Value: false
Key: querycoord.channeltasktimeout, Value: 60000
Key: querycoord.overloadedmemorythresholdpercentage, Value: 90
Key: querycoord.distpullinterval, Value: 500
Key: querycoord.checkinterval, Value: 10000
Key: querycoord.checkhandoffinterval, Value: 5000
Key: querycoord.taskexecutioncap, Value: 256
Key: querycoord.taskmergecap, Value: 8
Key: querycoord.autohandoff, Value: true
Key: querycoord.address, Value: localhost
Key: querycoord.port, Value: 19531
Key: querycoord.memoryusagemaxdifferencepercentage, Value: 30
Key: querycoord.refreshtargetsintervalseconds, Value: 300
Key: querycoord.balanceintervalseconds, Value: 60
Key: querycoord.loadtimeoutseconds, Value: 1800
Key: querycoord.globalrowcountfactor, Value: 0.1
Key: querycoord.scoreunbalancetolerationfactor, Value: 0.05
Key: querycoord.reverseunbalancetolerationfactor, Value: 1.3
Key: querycoord.balancer, Value: ScoreBasedBalancer
Key: querycoord.autobalance, Value: true
Key: querycoord.segmenttasktimeout, Value: 120000
```

--------------------------------

### Over-tokenization Example

Source: https://milvus.io/docs/choose-the-right-analyzer-for-your-use-case.md

Examples of inputs that are incorrectly split by the standard analyzer.

```text
* "user_id" → ['user', 'id']
  * "C++" → ['c']
```

--------------------------------

### Initialize and Search with MilvusClient

Source: https://milvus.io/docs/agents_overview.md

Demonstrates the end-to-end workflow of defining a schema, creating a collection with auto-indexing, inserting data, and performing a vector search.

```python
from pymilvus import MilvusClient, DataType

client = MilvusClient(uri="http://localhost:19530")

# 1. Define schema
schema = client.create_schema(auto_id=True)
schema.add_field("id", DataType.INT64, is_primary=True)
schema.add_field("vector", DataType.FLOAT_VECTOR, dim=768)
schema.add_field("text", DataType.VARCHAR, max_length=512)

# 2. Define index
index_params = client.prepare_index_params()
index_params.add_index(field_name="vector", index_type="AUTOINDEX", metric_type="COSINE")

# 3. Create collection (auto-indexes and auto-loads)
client.create_collection(collection_name="docs", schema=schema, index_params=index_params)

# 4. Insert
client.insert(collection_name="docs", data=[
    {"vector": [0.1] * 768, "text": "first doc"},
    {"vector": [0.2] * 768, "text": "second doc"},
])

# 5. Search
results = client.search(
    collection_name="docs",
    data=[[0.15] * 768],
    limit=5,
    output_fields=["text"],
)
```

--------------------------------

### Install Dependencies

Source: https://milvus.io/docs/video_search_with_twelvelabs_and_milvus.md

Install the necessary Twelve Labs and Milvus Python libraries.

```bash
pip install twelvelabs pymilvus
```

--------------------------------

### List all configurations

Source: https://milvus.io/docs/dynamic_config.md

View all configuration items under the specified root path.

```bash
$ etcdctl get --prefix by-dev/config
# or
$ birdwatcher -olc "#connect --etcd 127.0.0.1:2379 --rootPath=by-dev,show config-etcd"
```

--------------------------------

### Install OpenSSL on Ubuntu

Source: https://milvus.io/docs/tls.md

Install OpenSSL using the apt package manager.

```bash
sudo apt install openssl

  
```

--------------------------------

### Install Dependencies

Source: https://milvus.io/docs/llama_agents_metadata.md

Install the required packages for Llama-agents, Milvus, and LlamaIndex integrations.

```bash
$ pip install llama-agents pymilvus milvus-lite openai python-dotenv
```

```bash
$ pip install llama-index-vector-stores-milvus llama-index-readers-file llama-index-llms-ollama llama-index-llms-mistralai llama-index-embeddings-mistralai
```

--------------------------------

### Start Attu in Development Mode

Source: https://milvus.io/docs/attu.md

Initializes the Attu application with a specified admin user and password.

```bash
ATTU_ADMIN_USER=admin \
ATTU_ADMIN_PASSWORD='Change-me-please-123' \
pnpm --filter @attu/app dev --host 127.0.0.1
```

--------------------------------

### Download Example Data

Source: https://milvus.io/docs/contextual_retrieval_with_milvus.md

Download the JSON and JSONL files required for the contextual embeddings demonstration.

```bash
$ wget https://raw.githubusercontent.com/anthropics/anthropic-cookbook/refs/heads/main/skills/contextual-embeddings/data/codebase_chunks.json
$ wget https://raw.githubusercontent.com/anthropics/anthropic-cookbook/refs/heads/main/skills/contextual-embeddings/data/evaluation_set.jsonl
```

--------------------------------

### Install dependencies

Source: https://milvus.io/docs/langextract_milvus_demo.md

Install the required Python packages for the LangExtract and Milvus integration.

```bash
$ pip install --upgrade pymilvus milvus-lite langextract google-genai requests tqdm pandas
```
Tokens:
Raw