> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getnetra.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Milvus

> Trace Milvus vector database operations with Netra auto-instrumentation. Monitor collection searches, data inserts, and index queries automatically.

<img src="https://mintcdn.com/netra/IXT7TOAHn4HQhvyF/images/integration-logos/vector-databases/milvus.png?fit=max&auto=format&n=IXT7TOAHn4HQhvyF&q=85&s=1a46d8b3b7679a64e554b9ab5b88cde3" alt="Milvus" width="346" height="80" data-path="images/integration-logos/vector-databases/milvus.png" />

## Installation

Install both the Netra SDK and Milvus:

<CodeGroup>
  ```bash Python theme={null}
  pip install netra-sdk pymilvus
  ```

  ```bash Typescript theme={null}
  npm install netra-sdk @zilliz/milvus2-sdk-node
  ```
</CodeGroup>

## Usage

Initialize the Netra SDK to automatically trace all Milvus operations:

<CodeGroup>
  ```python Python theme={null}
  from netra import Netra
  from pymilvus import MilvusClient
  import os

  # Initialize Netra
  Netra.init(
      headers=f"x-api-key={os.environ.get('NETRA_API_KEY')}",
      trace_content=True
  )

  # Create Milvus client - automatically traced
  client = MilvusClient(
      uri=os.environ.get('MILVUS_URI'),
      token=os.environ.get('MILVUS_TOKEN')
  )

  # Create collection
  client.create_collection(
      collection_name="my_collection",
      dimension=384
  )
  ```

  ```typescript Typescript theme={null}
  import { Netra } from "netra-sdk";
  import { MilvusClient } from "@zilliz/milvus2-sdk-node";

  // Initialize Netra
  await Netra.init({
    headers: `x-api-key=${process.env.NETRA_API_KEY}`,
    traceContent: true
  });

  // Create Milvus client - automatically traced
  const client = new MilvusClient({
    address: process.env.MILVUS_ADDRESS,
    token: process.env.MILVUS_TOKEN
  });

  // Create collection
  await client.createCollection({
    collection_name: "my_collection",
    dimension: 384
  });
  ```
</CodeGroup>

### Collection Operations

Trace collection creation and management:

<CodeGroup>
  ```python Python theme={null}
  from netra.decorators import task
  from netra import SpanWrapper

  @task()
  def create_collection(client: MilvusClient, name: str, dimension: int):
      span = SpanWrapper("milvus-create-collection", {
          "collection.name": name,
          "vector.dimension": dimension
      }).start()
      
      client.create_collection(
          collection_name=name,
          dimension=dimension
      )
      
      span.end()
  ```

  ```typescript Typescript theme={null}
  import { task, SpanWrapper } from "netra-sdk";

  @task()
  async function createCollection(client: MilvusClient, name: string, dimension: number) {
    const span = new SpanWrapper("milvus-create-collection", {
      "collection.name": name,
      "vector.dimension": dimension
    }).start();
    
    await client.createCollection({
      collection_name: name,
      dimension: dimension
    });
    
    span.end();
  }
  ```
</CodeGroup>

### Vector Insertion

Trace entity insertions:

<CodeGroup>
  ```python Python theme={null}
  from netra.decorators import task
  from netra import SpanWrapper, ActionModel

  @task()
  def insert_vectors(client: MilvusClient, collection: str, data: list):
      span = SpanWrapper("milvus-insert", {
          "collection": collection,
          "entities.count": len(data)
      }).start()
      
      result = client.insert(
          collection_name=collection,
          data=data
      )
      
      span.set_action([ActionModel(
          action="insert",
          action_type="database.insert",
          success=True,
          affected_records=[{"id": str(d["id"])} for d in data],
          metadata={"collection": collection, "inserted": result["insert_count"]}
      )])
      span.set_attribute("insert.count", result["insert_count"])
      span.end()
      
      return result
  ```

  ```typescript Typescript theme={null}
  import { task, SpanWrapper, ActionModel } from "netra-sdk";

  @task()
  async function insertVectors(client: MilvusClient, collection: string, data: any[]) {
    const span = new SpanWrapper("milvus-insert", {
      "collection": collection,
      "entities.count": data.length
    }).start();
    
    const result = await client.insert({
      collection_name: collection,
      data: data
    });
    
    span.setAction([{
      action: "insert",
      action_type: "database.insert",
      success: true,
      affected_records: data.map(d => ({ id: String(d.id) })),
      metadata: { collection, inserted: result.insert_cnt }
    }]);
    span.setAttribute("insert.count", result.insert_cnt);
    span.end();
    
    return result;
  }
  ```
</CodeGroup>

### Vector Search

Trace similarity searches:

<CodeGroup>
  ```python Python theme={null}
  from netra.decorators import workflow
  from netra import SpanWrapper

  @workflow()
  def search_vectors(client: MilvusClient, collection: str, query: list[float], limit: int = 5):
      span = SpanWrapper("milvus-search", {
          "collection": collection,
          "query.dimension": len(query),
          "limit": limit
      }).start()
      
      results = client.search(
          collection_name=collection,
          data=[query],
          limit=limit
      )
      
      span.set_attribute("results.count", len(results[0]))
      span.end()
      
      return results
  ```

  ```typescript Typescript theme={null}
  import { workflow, SpanWrapper } from "netra-sdk";

  @workflow()
  async function searchVectors(client: MilvusClient, collection: string, query: number[], limit: number = 5) {
    const span = new SpanWrapper("milvus-search", {
      "collection": collection,
      "query.dimension": query.length,
      "limit": limit
    }).start();
    
    const results = await client.search({
      collection_name: collection,
      data: [query],
      limit: limit
    });
    
    span.setAttribute("results.count", results[0]?.length || 0);
    span.end();
    
    return results;
  }
  ```
</CodeGroup>

### Filtered Search

Trace searches with filters:

<CodeGroup>
  ```python Python theme={null}
  from netra.decorators import task
  from netra import SpanWrapper

  @task()
  def filter_search(client: MilvusClient, collection: str, query: list[float], filter: str):
      span = SpanWrapper("milvus-filter-search", {
          "collection": collection,
          "filter": filter
      }).start()
      
      results = client.search(
          collection_name=collection,
          data=[query],
          filter=filter,
          limit=10
      )
      
      span.set_attribute("results.count", len(results[0]))
      span.end()
      
      return results
  ```

  ```typescript Typescript theme={null}
  import { task, SpanWrapper } from "netra-sdk";

  @task()
  async function filterSearch(client: MilvusClient, collection: string, query: number[], filter: string) {
    const span = new SpanWrapper("milvus-filter-search", {
      "collection": collection,
      "filter": filter
    }).start();
    
    const results = await client.search({
      collection_name: collection,
      data: [query],
      filter: filter,
      limit: 10
    });
    
    span.setAttribute("results.count", results[0]?.length || 0);
    span.end();
    
    return results;
  }
  ```
</CodeGroup>

## Next Steps

* [Quick Start Guide](https://docs.getnetra.ai/quick-start/python) - Complete setup and configuration
* [Decorators](https://docs.getnetra.ai/tracing/decorators) - Add custom tracing with `@workflow`, `@agent`, and `@task` decorators
* [Milvus Documentation](https://milvus.io/docs) - Official Milvus documentation