Skip to main content
skill CX Codex

milvus — Claude Code skill: features and installation

This Claude Code skill manages Milvus vector databases through the Python SDK. It activates for collection setup, vector operations, search, and access control.

Apache-2.0 ★ 48 updated 2026-03-24

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add zilliztech/milvus-skill --skill milvus -a claude-code
Open on GitHub

What milvus does

The skill connects Python code to Milvus and manages the database through pymilvus. It covers collection creation, vector inserts and deletes, index and partition management, plus similarity, hybrid, and full-text search. Database operations and user, role, and privilege management are included too.

It requires Python 3.8+, the pymilvus package, and a running Milvus instance; Milvus Lite can serve for development. Before writing connection code, the agent asks for the deployment type and URI, authentication details when required, and a database name if the default is not used. Connection values must come from the user rather than assumptions.

What it helps with

  • connect Python code to a Milvus instance
  • create a collection with a custom schema
  • insert, update, or remove vectors
  • run similarity or hybrid searches
  • manage indexes, partitions, and access privileges

Example prompts for the agent

  • Connect my Python app to Milvus and create a vector collection.
  • Insert these records into the collection and search for similar vectors.
  • Set up users, roles, and access privileges for this Milvus database.

How to install milvus

1Skills CLI (Vercel)

npx skills add zilliztech/milvus-skill --skill milvus -a claude-code

2Manually: put the files in place

~/.claude/skills/milvus/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/milvus/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about milvus

How do I install milvus in Claude Code?

Run npx skills add zilliztech/milvus-skill --skill milvus -a claude-code. The skill file is at ~/.claude/skills/milvus/SKILL.md.

What does the milvus skill do?

It uses the pymilvus Python SDK to manage Milvus collections and vectors, run searches, and configure access controls.

What does milvus require?

It requires Python 3.8+, the pymilvus package, and a running Milvus instance. Milvus Lite is an option for development.

Source text

SKILL.md · Apache-2.0
---
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](https://milvus.io/) 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:
> 1. **Deployment type** — Milvus Lite (local file), Standalone/Cluster (self-hosted), or Zilliz Cloud (managed)?
> 2. **URI** — For self-hosted: host and port (e.g., `http://localhost:19530`). For Zilliz Cloud: the endpoint URL.
> 3. **Authentication** — Token, API key, or username/password if required.
> 4. **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.

```python
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

```python
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)

```python
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

```python
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](references/collection.md) for data types, add_field parameters, and all collection operations.**

### Other Collection Operations

```python
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](references/vector.md) for hybrid search, full-text search, iterators, filter syntax, and detailed examples.**

### Insert / Upsert

```python
# 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)

```python
# 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

```python
# 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](references/vector.md).

---

## Index Management

**See [references/index.md](references/index.md) for index types, metric types, and parameters.**

```python
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](references/partition.md) |
| Database Management | [references/database.md](references/database.md) |
| User & Role Management (RBAC) | [references/user-role.md](references/user-role.md) |
| Common Patterns (RAG, Semantic Search) | [references/patterns.md](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.

© zilliztech · Apache-2.0 · zilliztech/milvus-skill

Similar skills

All skills for Data and databases →

Project sponsors

Companies that keep this analytics open