Milvus

Die skalierbarste Open-Source-Vektor-Datenbank für KI-Anwendungen — entwickelt für Milliarden von Vektoren

Milvus ist eine Open-Source-Vektor-Datenbank, die speziell für skalierbare Similarity-Suche und KI-Anwendungen entwickelt wurde. Ursprünglich von Zilliz erstellt und an die LF AI & Data Foundation gespendet, betreibt Milvus Produktions-KI-Workloads bei Unternehmen wie NVIDIA, AT&T, IBM und Salesforce. Es ist die bevorzugte Wahl, wenn Sie auf Milliarden von Vektoren skalieren müssen.

GitHub: milvus-io/milvus — 32K+ ⭐

Milvus vs Qdrant — Wann welches wählen

Kriterien

Milvus

Qdrant

Skalierung

Milliarden von Vektoren

Hunderte Millionen

Architektur

Verteilt (mehrere Dienste)

Einzelne Binärdatei

Einrichtungsaufwand

Höher

Niedriger

GPU-Index-Unterstützung

✅ Native GPU FAISS

Begrenzt

Multi-Tenancy

✅ Partitionen + Aliase

Sammlungsbasiert

Streaming-Ingestion

✅ Kafka/Pulsar

Begrenzt

Hybride Suche

✅ Dicht + spärlich

✅

Cloudverwaltete Option

Zilliz Cloud

Qdrant Cloud

Wählen Sie Milvus, wenn: Sie auf Milliarden von Vektoren skalieren müssen, GPU-beschleunigtes Indexing (IVF_FLAT_GPU) benötigen oder Enterprise-Funktionen wie Multi-Tenancy, Streaming-Ingestion und rollenbasierte Zugriffskontrolle erforderlich sind.

Milvus-Architektur

Milvus im Standalone-Modus (Einzelserver) umfasst:

milvus — der Hauptdienst (Proxy-, Query-, Data-, Index-Koordinatoren)
etcd — Metadatenspeicher und Service-Discovery
MinIO — Objektspeicher für Segmentdaten

Im verteilten Modus (Cluster) skaliert jede Komponente unabhängig.

Voraussetzungen

Clore.ai-Konto mit GPU-Vermietung
Docker Compose (in der Regel vorinstalliert)
Grundkenntnisse in Python
16GB+ RAM (32GB für Produktion empfohlen)

Schritt 1 — Mieten Sie einen GPU-Server auf Clore.ai

Gehe zu clore.ai → Marktplatz
Empfohlene GPU: RTX 4090 oder A100 für GPU-beschleunigtes Indexing
CPU-Alternative: Jeder Server mit 32GB+ RAM für CPU-basiertes Indexing

Mindestanforderungen:

CPU: 8 Kerne
RAM: 16GB (32GB empfohlen)
Festplatte: 50GB SSD/NVMe
GPU: Optional (nur für GPU-Index-Typen erforderlich)

GPU-Index-Typen in Milvus (IVF_FLAT_GPU, IVFSQ8_GPU) erfordern CUDA-fähige GPUs und beschleunigen den Indexaufbau für große Sammlungen erheblich. Wenn Sie planen, häufig 10M+ Vektoren zu indexieren, amortisiert sich GPU-Indexing schnell.

Schritt 2 — Milvus Standalone bereitstellen

Docker-Image:

milvusdb/milvus:v2.4.0

Milvus Standalone benötigt etcd und MinIO. Verwenden Sie Docker Compose für die einfachste Einrichtung.

Ports:

22
19530

Port 19530: Milvus SDK/gRPC-Port (primär)
Port 9091: Milvus REST API und Health-Check (intern)

Umgebungsvariablen:

NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility

Schritt 3 — Einrichtung mit Docker Compose

SSH auf Ihren Clore.ai-Server und erstellen Sie die Compose-Datei:

ssh root@<server-ip> -p <ssh-port>

# Installieren Sie Docker Compose, falls nicht vorhanden
which docker-compose || pip install docker-compose
# Oder verwenden Sie das Docker-Plugin:
docker compose version

# Projektverzeichnis erstellen
mkdir -p /opt/milvus && cd /opt/milvus

# Offizielle Milvus-Standalone-Compose-Datei herunterladen
wget https://github.com/milvus-io/milvus/releases/download/v2.4.0/milvus-standalone-docker-compose.yml \
    -O docker-compose.yml

# Die Compose-Datei überprüfen
cat docker-compose.yml

Passen Sie docker-compose.yml an

version: '3.5'

services:
  etcd:
    container_name: milvus-etcd
    image: quay.io/coreos/etcd:v3.5.5
    environment:
      - ETCD_AUTO_COMPACTION_MODE=revision
      - ETCD_AUTO_COMPACTION_RETENTION=1000
      - ETCD_QUOTA_BACKEND_BYTES=4294967296
      - ETCD_SNAPSHOT_COUNT=50000
    volumes:
      - /opt/milvus/etcd:/etcd
    command: etcd -advertise-client-urls=http://127.0.0.1:2379 -listen-client-urls http://0.0.0.0:2379 --data-dir /etcd
    healthcheck:
      test: ["CMD", "etcdctl", "endpoint", "health"]
      interval: 30s
      timeout: 20s
      retries: 3

  minio:
    container_name: milvus-minio
    image: minio/minio:RELEASE.2023-03-13T19-46-17Z
    environment:
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadmin
    ports:
      - "9001:9001"
      - "9000:9000"
    volumes:
      - /opt/milvus/minio:/minio_data
    command: minio server /minio_data --console-address ":9001"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3

  standalone:
    container_name: milvus-standalone
    image: milvusdb/milvus:v2.4.0
    command: ["milvus", "run", "standalone"]
    security_opt:
      - seccomp:unconfined
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
    volumes:
      - /opt/milvus/milvus:/var/lib/milvus
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9091/healthz"]
      interval: 30s
      start_period: 90s
      timeout: 20s
      retries: 3
    ports:
      - "19530:19530"
      - "9091:9091"
    depends_on:
      - "etcd"
      - "minio"
    deploy:
      resources:
        reservations:
          devices:
            - capabilities: [gpu]  # GPU-Zugriff aktivieren

Milvus starten

cd /opt/milvus
docker compose up -d

# Warten Sie, bis die Dienste gestartet sind (~60 Sekunden)
sleep 60

# Prüfen Sie, ob alle Dienste gesund sind
docker compose ps

# Milvus-Health prüfen
curl http://localhost:9091/healthz
# Erwartet: {"status":"ok"}

# Logs anzeigen
docker compose logs -f standalone --tail 50

Schritt 4 — Python-Client installieren

pip install pymilvus sentence-transformers numpy tqdm

# Verbindung verifizieren
python3 << 'EOF'
from pymilvus import connections, utility

connections.connect("default", host="localhost", port="19530")
print(f"Milvus verbunden!")
print(f"Version: {utility.get_server_version()}")
EOF

Schritt 5 — Erstelle eine Collection

In Milvus ist eine Sammlung ähnlich wie eine Datenbanktabelle. Sie hat ein Schema mit typisierten Feldern, einschließlich Vektorfeldern.

from pymilvus import (
    connections,
    FieldSchema,
    CollectionSchema,
    DataType,
    Collection,
    utility
)

# Verbinden
connections.connect("default", host="localhost", port="19530")

# Schema definieren
fields = [
    FieldSchema(
        name="id",
        dtype=DataType.INT64,
        is_primary=True,
        auto_id=True           # IDs automatisch generieren
    ),
    FieldSchema(
        name="text",
        dtype=DataType.VARCHAR,
        max_length=2048        # Maximale Textlänge
    ),
    FieldSchema(
        name="source",
        dtype=DataType.VARCHAR,
        max_length=256
    ),
    FieldSchema(
        name="category",
        dtype=DataType.VARCHAR,
        max_length=128
    ),
    FieldSchema(
        name="year",
        dtype=DataType.INT32
    ),
    FieldSchema(
        name="embedding",
        dtype=DataType.FLOAT_VECTOR,
        dim=384                # Dimension Ihres Embedding-Modells
    )
]

schema = CollectionSchema(
    fields=fields,
    description="Dokumenten-Embeddings für semantische Suche",
    enable_dynamic_field=True  # Erlaubt das Hinzufügen von Feldern, die nicht im Schema sind
)

# Collection erstellen
collection_name = "documents"
if utility.has_collection(collection_name):
    utility.drop_collection(collection_name)

collection = Collection(
    name=collection_name,
    schema=schema,
    using="default"
)
print(f"Sammlung '{collection_name}' erstellt!")

Schritt 6 — Index erstellen

Erstellen Sie vor dem Laden der Daten für die Suche einen geeigneten Index:

from pymilvus import Collection

collection = Collection("documents")

# HNSW-Index (am besten für die meisten Anwendungsfälle, geringe Latenz)
hnsw_params = {
    "metric_type": "COSINE",     # COSINE, L2 oder IP (Inner Product)
    "index_type": "HNSW",
    "params": {
        "M": 16,                 # HNSW-Graph-Konnektivität (8-64)
        "efConstruction": 200    # Bauzeit-Suchtiefe
    }
}

# IVF_FLAT-Index (CPU, gut für große Sammlungen)
ivf_params = {
    "metric_type": "COSINE",
    "index_type": "IVF_FLAT",
    "params": {
        "nlist": 1024            # Anzahl der Cluster (Quadratwurzel der Datenmenge ist typisch)
    }
}

# GPU_IVF_FLAT-Index (erfordert CUDA-GPU — am schnellsten für Batch-Abfragen)
gpu_ivf_params = {
    "metric_type": "L2",
    "index_type": "GPU_IVF_FLAT",
    "params": {
        "nlist": 1024,
        "cache_dataset_on_device": True
    }
}

# Index auf dem Embedding-Feld erstellen
collection.create_index(
    field_name="embedding",
    index_params=hnsw_params,
    index_name="embedding_idx"
)

# Skalarindex für gefilterte Suche erstellen
collection.create_index(field_name="category", index_name="category_idx")
collection.create_index(field_name="year", index_name="year_idx")

print("Indizes erstellt!")
collection.load()  # In den Speicher laden, um zu suchen

Schritt 7 — Daten einfügen

from pymilvus import Collection
from sentence_transformers import SentenceTransformer
import tqdm

collection = Collection("documents")
model = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")

# Ihre Dokumente
documents = [
    {
        "text": "Milvus ist eine Open-Source-Vektor-Datenbank für skalierbare KI-Anwendungen.",
        "source": "documentation",
        "category": "database",
        "year": 2024
    },
    {
        "text": "HNSW bietet schnelle approximative Nearest-Neighbor-Suche mit hoher Wiederfindungsrate.",
        "source": "research",
        "category": "algorithm",
        "year": 2023
    },
    {
        "text": "GPU-beschleunigtes Indexing reduziert die Aufbauzeit für große Vektorsammlungen drastisch.",
        "source": "blog",
        "category": "performance",
        "year": 2024
    },
    # Tausende weitere Dokumente hier hinzufügen
]

def insert_batch(docs: list, batch_size: int = 1000):
    texts = [d["text"] for d in docs]
    
    # GPU-beschleunigtes Embedding
    embeddings = model.encode(
        texts,
        batch_size=256,
        show_progress_bar=False,
        normalize_embeddings=True
    )
    
    # In Milvus einfügen
    data = {
        "text": [d["text"] for d in docs],
        "source": [d["source"] for d in docs],
        "category": [d["category"] for d in docs],
        "year": [d["year"] for d in docs],
        "embedding": embeddings.tolist()
    }
    
    result = collection.insert(data)
    return result.insert_count

# In Chargen einfügen
BATCH_SIZE = 1000
total_inserted = 0

for i in range(0, len(documents), BATCH_SIZE):
    batch = documents[i:i + BATCH_SIZE]
    count = insert_batch(batch)
    total_inserted += count
    print(f"Eingefügt {total_inserted}/{len(documents)} Dokumente")

# Flush, um sicherzustellen, dass Daten persistiert und indexiert sind
collection.flush()
print(f"Insgesamt eingefügt und geflusht: {total_inserted}")

Schritt 8 — Suche und Abfragen

Basis Semantische Suche

from pymilvus import Collection
from sentence_transformers import SentenceTransformer

collection = Collection("documents")
collection.load()

model = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")

def search(query: str, top_k: int = 10):
    query_embedding = model.encode(
        [query],
        normalize_embeddings=True
    )[0].tolist()
    
    results = collection.search(
        data=[query_embedding],
        anns_field="embedding",
        param={
            "metric_type": "COSINE",
            "params": {"ef": 64}    # HNSW-Suchzeit-Parameter (ef >= top_k)
        },
        limit=top_k,
        output_fields=["text", "source", "category", "year"]
    )
    
    return results[0]

# Suche
hits = search("how does vector similarity search work")
for hit in hits:
    print(f"Score: {hit.score:.4f}")
    print(f"Text: {hit.entity.get('text')[:100]}")
    print(f"Quelle: {hit.entity.get('source')}")
    print()

Gefilterte Suche

from pymilvus import Collection

collection = Collection("documents")

# Suche mit Metadatenfilter (boolescher Ausdruck)
results = collection.search(
    data=[query_embedding],
    anns_field="embedding",
    param={"metric_type": "COSINE", "params": {"ef": 64}},
    limit=10,
    expr='category == "database" and year >= 2023',  # Boolescher Filter
    output_fields=["text", "category", "year"]
)

Hybride Suche (Dicht + Spärlich)

# Milvus 2.4+ unterstützt hybride dicht+spärlich Suche
from pymilvus import AnnSearchRequest, WeightedRanker, Collection

collection = Collection("documents")

# Dichte Suchanfrage
dense_req = AnnSearchRequest(
    data=[dense_embedding],
    anns_field="embedding",
    param={"metric_type": "COSINE", "params": {"ef": 64}},
    limit=20
)

# Spärliche Suchanfrage (erfordert spärliches Vektorfeld)
sparse_req = AnnSearchRequest(
    data=[sparse_embedding],
    anns_field="sparse_embedding",
    param={"metric_type": "IP"},
    limit=20
)

# Kombination mit Reciprocal Rank Fusion
results = collection.hybrid_search(
    [dense_req, sparse_req],
    rerank=WeightedRanker(0.7, 0.3),  # 70% dicht, 30% spärlich
    limit=10,
    output_fields=["text"]
)

Schritt 9 — Einen RAG-Service aufbauen

pip install fastapi uvicorn openai

cat > /workspace/milvus_rag.py << 'EOF'
from fastapi import FastAPI
from pydantic import BaseModel
from pymilvus import Collection, connections
from sentence_transformers import SentenceTransformer
from openai import OpenAI
import os

app = FastAPI(title="Milvus RAG API")

# Beim Start initialisieren
connections.connect("default", host="localhost", port="19530")
collection = Collection("documents")
collection.load()
embedder = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")
llm = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

class QueryRequest(BaseModel):
    question: str
    n_results: int = 5

@app.get("/health")
async def health():
    return {"status": "ok", "vectors": collection.num_entities}

@app.post("/search")
async def semantic_search(req: QueryRequest):
    embedding = embedder.encode(
        [req.question],
        normalize_embeddings=True
    )[0].tolist()
    
    results = collection.search(
        data=[embedding],
        anns_field="embedding",
        param={"metric_type": "COSINE", "params": {"ef": 64}},
        limit=req.n_results,
        output_fields=["text", "source", "category"]
    )
    
    return {
        "results": [
            {
                "text": hit.entity.get("text"),
                "source": hit.entity.get("source"),
                "score": hit.score
            }
            for hit in results[0]
        ]
    }

@app.post("/rag")
async def rag(req: QueryRequest):
    embedding = embedder.encode([req.question], normalize_embeddings=True)[0].tolist()
    
    hits = collection.search(
        data=[embedding],
        anns_field="embedding",
        param={"metric_type": "COSINE", "params": {"ef": 64}},
        limit=req.n_results,
        output_fields=["text", "source"]
    )[0]
    
    context = "\n\n".join([
        f"[{hit.entity.get('source')}]: {hit.entity.get('text')}"
        for hit in hits if hit.score > 0.4
    ])
    
    response = llm.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Antwort basierend auf dem Kontext. Seien Sie prägnant."},
            {"role": "user", "content": f"Kontext:\n{context}\n\nFrage: {req.question}"}
        ]
    )
    
    return {"answer": response.choices[0].message.content, "context_used": len(hits)}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
EOF

python3 /workspace/milvus_rag.py

Schritt 10 — Überwachen und Verwalten

from pymilvus import connections, utility, Collection

connections.connect("default", host="localhost", port="19530")

# Alle Collections auflisten
print("Sammlungen:", utility.list_collections())

# Sammlungsstatistiken
col = Collection("documents")
print(f"Eintragsanzahl: {col.num_entities:,}")
print(f"Schema: {col.schema}")

# Partitionsverwaltung
col.create_partition("2024_docs")
col.create_partition("2023_docs")

# Einfügen mit Partition
col.insert(data, partition_name="2024_docs")

# Spezifische Partition durchsuchen
results = col.search(
    data=[query_vec],
    anns_field="embedding",
    param={"metric_type": "COSINE", "params": {"ef": 64}},
    limit=10,
    partition_names=["2024_docs"]  # Nur diese Partition durchsuchen
)

Fehlerbehebung

Dienste starten nicht

# Überprüfen Sie die Container-Logs
docker compose logs etcd
docker compose logs minio
docker compose logs standalone

# Festplattenspeicher prüfen
df -h /opt/milvus

# Dienste neu starten
docker compose restart

Connection Refused auf 19530

# Überprüfen, ob Milvus lauscht
netstat -tlnp | grep 19530

# Prüfe Gesundheitszustand
curl http://localhost:9091/healthz

# Zeit für den Start erlauben (90 Sekunden)
docker compose logs standalone | tail -20

Index-Bau-Timeout für große Sammlungen

# Timeout für große Index-Builds erhöhen
from pymilvus import Collection

collection = Collection("documents")
collection.create_index(
    field_name="embedding",
    index_params=hnsw_params,
    timeout=3600  # 1 Stunde Timeout
)

Hoher Speicherverbrauch

# Milvus-Speicherlimits in docker-compose.yml konfigurieren
# Zum Standalone-Dienst hinzufügen:
deploy:
  resources:
    limits:
      memory: 16g

Leitfaden zur Auswahl des Index-Typs

Index-Typ

Am besten für

Speicher

Geschwindigkeit

GPU erforderlich

FLAT

Klein (<1M), exakte Suche

Hoch

Langsam

Nein

IVF_FLAT

Mittel (1M–10M)

Mittel

Gut

Nein

HNSW

Geringe Latenz, <100M

Hoch

Ausgezeichnet

Nein

IVF_SQ8

Komprimiert, groß

Niedrig

Gut

Nein

GPU_IVF_FLAT

Schnelle Batch-Abfragen

GPU+RAM

Beste

DISKANN

Milliarden-Skala

Niedrig (Festplatte)

Gut

Nein

Leistungs-Benchmarks

Sammlung Größe

Index

GPU

QPS

1M Vektoren

HNSW

RTX 3090

~8,000

10M Vektoren

IVF_FLAT

RTX 4090

~2,500

10M Vektoren

GPU_IVF_FLAT

A100

~12,000

100M Vektoren

DISKANN

A100

~1,200

Weitere Ressourcen

Milvus-Dokumentation
Milvus GitHub
PyMilvus-Dokumentation
Milvus Bootcamp — Beispielanwendungen
Zilliz Cloud — Verwaltetes Milvus
Vektor-Datenbank-Vergleich
Attu GUI — Web-UI für Milvus-Verwaltung

Milvus auf Clore.ai ist die ideale Lösung für KI-Anwendungen, die über Hunderte Millionen Vektoren hinaus skalieren müssen. In Kombination mit GPU-beschleunigter Embedding-Erzeugung können Sie erstklassige semantische Suche- und RAG-Systeme zu einem Bruchteil der Kosten verwalteter Clouds aufbauen.

Clore.ai GPU-Empfehlungen

Anwendungsfall

Empfohlene GPU

Geschätzte Kosten auf Clore.ai

Entwicklung/Tests

RTX 3090 (24GB)

~$0.12/gpu/hr

Produktionsfähige Vektorsuche

RTX 3090 (24GB)

~$0.12/gpu/hr

Hochdurchsatz-Embedding

RTX 4090 (24GB)

~$0.70/gpu/hr

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.

VorherigeQdrant NächsteWeaviate

Zuletzt aktualisiert vor 14 Tagen

War das hilfreich?

hashtagMilvus vs Qdrant — Wann welches wählen

hashtagMilvus-Architektur

hashtagVoraussetzungen

hashtagSchritt 1 — Mieten Sie einen GPU-Server auf Clore.ai

hashtagSchritt 2 — Milvus Standalone bereitstellen

hashtagSchritt 3 — Einrichtung mit Docker Compose

hashtagPassen Sie docker-compose.yml an

hashtagMilvus starten

hashtagSchritt 4 — Python-Client installieren

hashtagSchritt 5 — Erstelle eine Collection

hashtagSchritt 6 — Index erstellen

hashtagSchritt 7 — Daten einfügen

hashtagSchritt 8 — Suche und Abfragen

hashtagBasis Semantische Suche

hashtagGefilterte Suche

hashtagHybride Suche (Dicht + Spärlich)

hashtagSchritt 9 — Einen RAG-Service aufbauen

hashtagSchritt 10 — Überwachen und Verwalten

hashtagFehlerbehebung

hashtagDienste starten nicht

hashtagConnection Refused auf 19530

hashtagIndex-Bau-Timeout für große Sammlungen

hashtagHoher Speicherverbrauch

hashtagLeitfaden zur Auswahl des Index-Typs

hashtagLeistungs-Benchmarks

hashtagWeitere Ressourcen

hashtagClore.ai GPU-Empfehlungen

Milvus vs Qdrant — Wann welches wählen

Milvus-Architektur

Voraussetzungen

Schritt 1 — Mieten Sie einen GPU-Server auf Clore.ai

Schritt 2 — Milvus Standalone bereitstellen

Schritt 3 — Einrichtung mit Docker Compose

Passen Sie docker-compose.yml an

Milvus starten

Schritt 4 — Python-Client installieren

Schritt 5 — Erstelle eine Collection

Schritt 6 — Index erstellen

Schritt 7 — Daten einfügen

Schritt 8 — Suche und Abfragen

Basis Semantische Suche

Gefilterte Suche

Hybride Suche (Dicht + Spärlich)

Schritt 9 — Einen RAG-Service aufbauen

Schritt 10 — Überwachen und Verwalten

Fehlerbehebung

Dienste starten nicht

Connection Refused auf 19530

Index-Bau-Timeout für große Sammlungen

Hoher Speicherverbrauch

Leitfaden zur Auswahl des Index-Typs

Leistungs-Benchmarks

Weitere Ressourcen

Clore.ai GPU-Empfehlungen