name: milvus description: Operate Milvus vector database with pymilvus Python SDK. Use when the user wants to connect to Milvus, create collections, insert vectors, perform similarity search, hybrid search, full-text search, manage indexes, partitions, databases, or RBAC via Python code. license: Apache-2.0 compatibility: Requires Python 3.8+ and pymilvus (pip install pymilvus). Runs on macOS and Linux. metadata: author: zilliztech version: "1.0.0" allowed-tools: Bash Read Write

Milvus Vector Database Skill

Operate Milvus vector databases directly through Python code using the pymilvus SDK. Covers the full lifecycle — connecting, schema design, collection management, vector CRUD, search, hybrid search, full-text search, indexing, partitions, databases, and RBAC.

When to Use

Use this skill when the user wants to:

Connect to a Milvus instance (local, standalone, cluster, or Milvus Lite)
Create collections with custom schemas
Insert, upsert, search, query, get, or delete vectors
Perform hybrid search with reranking
Perform full-text search (BM25)
Manage indexes, partitions, databases
Set up users, roles, and access control (RBAC)
Build RAG pipelines, semantic search, or recommendation systems with Milvus
Iterate over large result sets with search/query iterators

Requirements

Python 3.8+
pymilvus (pip install pymilvus)
A running Milvus instance, or use Milvus Lite (embedded, file-based) for development

Capabilities Overview

| Area | What You Can Do | |------|----------------| | Connection | Connect to Milvus Lite, Standalone, Cluster, or Zilliz Cloud | | Collections | Create (quick or custom schema), list, describe, drop, rename, truncate, load, release | | Vectors | Insert, upsert, search, hybrid search, query, get, delete | | Full-Text Search | BM25-based keyword search with sparse vectors | | Iterators | Paginated search and query over large datasets | | Indexes | Create (AUTOINDEX, HNSW, IVF_FLAT, etc.), list, describe, drop | | Partitions | Create, list, load, release, drop | | Databases | Create, list, switch, drop | | RBAC | Users, roles, privileges management |

Connection

IMPORTANT: Before writing any connection code, you MUST ask the user for their connection details. Ask:

Deployment type — Milvus Lite (local file), Standalone/Cluster (self-hosted), or Zilliz Cloud (managed)?

URI — For self-hosted: host and port (e.g., http://localhost:19530). For Zilliz Cloud: the endpoint URL.

Authentication — Token, API key, or username/password if required.

Database name — If not using the default database.

Never assume or hardcode connection parameters. Use Milvus Lite (uri="./milvus.db") only if the user explicitly wants local/embedded mode for development.

from pymilvus import MilvusClient

# Milvus Lite (embedded, file-based — great for dev/test)
client = MilvusClient(uri="./milvus.db")

# Standalone / Cluster Milvus (ask user for actual host:port and credentials)
client = MilvusClient(uri="<USER_URI>", token="<USER_TOKEN>")

# Zilliz Cloud (ask user for endpoint and API key)
client = MilvusClient(uri="<USER_ZILLIZ_ENDPOINT>", token="<USER_API_KEY>")

Parameters:

| Parameter | Type | Description | |-----------|------|-------------| | uri | str | "./file.db" for Milvus Lite, "http://host:19530" for server | | token | str | API key or "username:password" | | user | str | Username (alternative to token) | | password | str | Password (alternative to token) | | db_name | str | Target database (default: "default") | | timeout | float | Operation timeout in seconds |

Async Client

from pymilvus import AsyncMilvusClient

async with AsyncMilvusClient(uri="<USER_URI>") as client:
    results = await client.search(collection_name="my_collection", data=[query_vector], limit=10)

Collection Management

Quick Create (auto schema + auto index + auto load)

client.create_collection(
    collection_name="my_collection",
    dimension=768,
    metric_type="COSINE"  # Optional: "COSINE" (default), "L2", "IP"
)

This automatically creates an id field (INT64, primary key, auto_id), a vector field (FLOAT_VECTOR), AUTOINDEX, and auto-loads the collection.

Custom Schema Create

from pymilvus import DataType

schema = client.create_schema(auto_id=False, enable_dynamic_field=True)
schema.add_field("id", DataType.INT64, is_primary=True)
schema.add_field("text", DataType.VARCHAR, max_length=512)
schema.add_field("embedding", DataType.FLOAT_VECTOR, dim=768)

index_params = client.prepare_index_params()
index_params.add_index(field_name="embedding", index_type="AUTOINDEX", metric_type="COSINE")

client.create_collection(collection_name="my_collection", schema=schema, index_params=index_params)

See references/collection.md for data types, add_field parameters, and all collection operations.

Other Collection Operations

client.list_collections()
client.describe_collection(collection_name="my_collection")
client.has_collection(collection_name="my_collection")
client.rename_collection(old_name="old", new_name="new")
client.drop_collection(collection_name="my_collection")
client.truncate_collection(collection_name="my_collection")
client.load_collection(collection_name="my_collection")
client.release_collection(collection_name="my_collection")
client.get_load_state(collection_name="my_collection")
client.get_collection_stats(collection_name="my_collection")

Quick create is best for prototyping; use custom schema for production.
A collection must be loaded before search or query.
Use enable_dynamic_field=True to allow inserting fields not defined in the schema.

Vector Operations

See references/vector.md for hybrid search, full-text search, iterators, filter syntax, and detailed examples.

Insert / Upsert

# Vectors must come from an embedding model — never use fake/placeholder vectors
from pymilvus import model

embedding_fn = model.dense.SentenceTransformerEmbeddingFunction(model_name="all-MiniLM-L6-v2")

docs = ["AI advances in 2024", "ML basics for beginners"]
vectors = embedding_fn.encode_documents(docs)

data = [
    {"id": 1, "text": docs[0], "embedding": vectors[0]},
    {"id": 2, "text": docs[1], "embedding": vectors[1]},
]
client.insert(collection_name="my_collection", data=data)
client.upsert(collection_name="my_collection", data=data)

Search (vector similarity)

# Use the same embedding model to encode the query
query_vectors = embedding_fn.encode_queries(["What is artificial intelligence?"])

results = client.search(
    collection_name="my_collection",
    data=query_vectors,
    anns_field="embedding",
    limit=10,
    output_fields=["text", "id"],
    filter='age > 20 and status == "active"',
    search_params={"metric_type": "COSINE", "params": {"nprobe": 10}}
)

Query / Get / Delete

# Query by filter
client.query(collection_name="my_collection", filter='id in [1, 2, 3]', output_fields=["text"], limit=100)

# Get by primary key
client.get(collection_name="my_collection", ids=[1, 2, 3], output_fields=["text"])

# Delete
client.delete(collection_name="my_collection", ids=[1, 2, 3])
client.delete(collection_name="my_collection", filter='status == "obsolete"')

Never use fake or placeholder vectors (e.g., [0.1, 0.2, ...]). Always generate vectors from an embedding model.
Use pip install "pymilvus[model]" for built-in embedding functions, or use any embedding model (OpenAI, Cohere, etc.).
Vector dimension in search must match the collection schema exactly.
The query embedding model must be the same model used to generate the stored vectors.
For large inserts, batch data into chunks (e.g., 1000 rows per batch).
For large result sets, use iterators — see references/vector.md.

Index Management

See references/index.md for index types, metric types, and parameters.

index_params = client.prepare_index_params()
index_params.add_index(
    field_name="embedding",
    index_type="HNSW",
    metric_type="COSINE",
    params={"M": 16, "efConstruction": 256}
)
client.create_index(collection_name="my_collection", index_params=index_params)

client.list_indexes(collection_name="my_collection")
client.describe_index(collection_name="my_collection", index_name="my_index")
client.drop_index(collection_name="my_collection", index_name="my_index")

AUTOINDEX is recommended for most use cases.
An index is required before loading a collection.

Additional Features

| Feature | Reference | |---------|-----------| | Partition Management | references/partition.md | | Database Management | references/database.md | | User & Role Management (RBAC) | references/user-role.md | | Common Patterns (RAG, Semantic Search) | references/patterns.md |

General Guidance

Always ask the user for connection details (URI, token/credentials) before writing connection code. Never assume or hardcode connection parameters.
Never generate fake or placeholder vectors. Always use an embedding model to produce real vectors. Suggest pip install "pymilvus[model]" for built-in embedding functions.
For quick prototyping, use Milvus Lite (uri="./file.db") — no server needed, but only if the user explicitly requests local/embedded mode.
A collection must be loaded into memory before search/query.
The vector dimension in search data must exactly match the collection schema.
The query embedding model must be the same model used to generate the stored vectors.
Before any destructive operation (drop collection, drop database, delete vectors), always confirm with the user.
Use enable_dynamic_field=True when the schema may evolve.
Prefer AUTOINDEX unless the user has specific performance requirements.
Use truncate_collection to clear all data without dropping the collection.
For large datasets, use iterators (search_iterator, query_iterator) instead of increasing limit.

Base de données vectorielles Milvus

Recommandé pour