Integrationen
Dynamiq and Zilliz Cloud Integration

Dynamiq and Zilliz Cloud Integration

Dynamiq and Zilliz Cloud integrate to power fast, secure, and context-aware AI agents, combining Dynamiq's enterprise agentic AI platform with visual workflow builder and Python SDK alongside Zilliz Cloud's high-performance vector storage for scalable RAG retrieval.

Verwenden Sie diese Integration kostenlos

Was ist Dynamiq
Dynamiq ist die Enterprise-Betriebsplattform für agentische KI. Sie ermöglicht es Teams, produktionsreife KI-Agenten und RAG-Workflows zu erstellen, zu koordinieren und zu implementieren, ohne mehrere separate Tools integrieren zu müssen. Sie bietet sowohl einen visuellen Drag-and-Drop-Builder als auch ein Open-Source-Python-SDK und gibt Entwicklern und Business-Anwendern die Flexibilität, agentische Anwendungen in SaaS-, Private-Cloud- oder vollständig air-gapped Umgebungen zu skalieren.

Durch die Integration mit Zilliz Cloud (vollständig verwaltetes Milvus) erhält Dynamiq Zugriff auf leistungsstarke Vektorspeicherung und -abfrage, die seine agentischen RAG-Workflows antreibt, indem die skalierbare Vektorinfrastruktur von Zilliz mit der Orchestrierungsschicht von Dynamiq kombiniert wird, um reaktionsschnelle, kontextbewusste Agenten zu ermöglichen, die über Enterprise-Wissensdatenbanken hinweg arbeiten.
Vorteile der Dynamiq + Zilliz Cloud Integration
- Skalierbare agentische RAG-Workflows: Dynamiqs Orchestrierungsschicht in Kombination mit dem leistungsstarken Vektorspeicher von Zilliz Cloud ermöglicht produktionsreife KI-Agenten, die Kontext aus umfangreichen Wissensdatenbanken von Unternehmen in Echtzeit abrufen können.
- Flexibilität durch zwei Builder: Teams können RAG-Workflows mit Dynamiqs visuellem Drag-and-drop-Builder oder dem Open-Source-Python-SDK erstellen, wobei Zilliz Cloud den Vektorspeicher in beiden Ansätzen nahtlos übernimmt.
- Sichere Unternehmensbereitstellung: Die Integration unterstützt SaaS-, Private-Cloud- und vollständig air-gapped Umgebungen, mit vollständiger Beobachtbarkeit und Guardrails rund um LLM-Aufrufe und Vektornutzung.
- Effiziente Dokumentenindexierung und -abfrage: Dynamiqs Writer Node nimmt Dokumente auf und indexiert sie in Zilliz Cloud, während der Retriever Node Agenten mit Milvus-gestützten Wissensdatenbanken für den Echtzeit-Kontextabruf verbindet.
So funktioniert die Integration
Dynamiq dient als Orchestrierungsplattform und stellt das agentenbasierte KI-Framework mit visuellem Workflow-Builder, Python SDK und LLM-Agentenfunktionen bereit. Es übernimmt die Dokumentverarbeitung, Workflow-Orchestrierung, Prompt-Verwaltung und Antwortgenerierung über seine modulare, knotenbasierte Architektur.

Zilliz Cloud dient als Vektordatenbankebene, speichert und indiziert Dokument-Embeddings über den MilvusDocumentWriter-Knoten von Dynamiq und bietet eine schnelle Ähnlichkeitssuche über den MilvusDocumentRetriever-Knoten. Es ermöglicht das effiziente Abrufen relevanter Kontexte aus großen Wissensdatenbanken.

Zusammen schaffen Dynamiq und Zilliz Cloud eine durchgängige agentenbasierte RAG-Lösung: Dokumente werden über Dynamiqs Indizierungs-Workflow verarbeitet, eingebettet und in Zilliz Cloud gespeichert. Wenn Nutzer mit KI-Agenten interagieren, fragt Dynamiqs Retrieval-Workflow Zilliz Cloud nach relevanten Dokument-Embeddings ab und übergibt den Kontext an das LLM, um detaillierte, kontextbewusste Antworten zu generieren — ganz ohne benutzerdefinierten Code oder Infrastruktur-Einrichtung.

Schritt-für-Schritt-Anleitung

1. Erforderliche Bibliotheken installieren

$ pip install dynamiq pymilvus

2. Den LLM-Agenten konfigurieren

In diesem Beispiel verwenden wir OpenAI als LLM. Bereiten Sie den API-Schlüssel als Umgebungsvariable vor:

import os

os.environ["OPENAI_API_KEY"] = "sk-***********"

3. Dokumentindizierungs-Flow — Bibliotheken importieren und Workflow initialisieren

from io import BytesIO
from dynamiq import Workflow
from dynamiq.nodes import InputTransformer
from dynamiq.connections import (
    OpenAI as OpenAIConnection,
    Milvus as MilvusConnection,
    MilvusDeploymentType,
)
from dynamiq.nodes.converters import PyPDFConverter
from dynamiq.nodes.splitters.document import DocumentSplitter
from dynamiq.nodes.embedders import OpenAIDocumentEmbedder
from dynamiq.nodes.writers import MilvusDocumentWriter

# Initialize the workflow
rag_wf = Workflow()

4. Die Knoten der Indizierungs-Pipeline definieren

Definieren Sie den PDF-Konverter, den Dokument-Splitter, die Einbettung und die Milvus-Vektorspeicher-Knoten:

# PDF Converter
converter = PyPDFConverter(document_creation_mode="one-doc-per-page")
converter_added = rag_wf.flow.add_nodes(converter)

# Document Splitter
document_splitter = DocumentSplitter(
    split_by="sentence",
    split_length=10,
    split_overlap=1,
    input_transformer=InputTransformer(
        selector={
            "documents": f"${[converter.id]}.output.documents",
        },
    ),
).depends_on(converter)
splitter_added = rag_wf.flow.add_nodes(document_splitter)

# Embedding Node
embedder = OpenAIDocumentEmbedder(
    connection=OpenAIConnection(api_key=os.environ["OPENAI_API_KEY"]),
    input_transformer=InputTransformer(
        selector={
            "documents": f"${[document_splitter.id]}.output.documents",
        },
    ),
).depends_on(document_splitter)
document_embedder_added = rag_wf.flow.add_nodes(embedder)

# Milvus Vector Store
vector_store = (
    MilvusDocumentWriter(
        connection=MilvusConnection(
            deployment_type=MilvusDeploymentType.FILE, uri="./milvus.db"
        ),
        index_name="my_milvus_collection",
        dimension=1536,
        create_if_not_exist=True,
        metric_type="COSINE",
    )
    .inputs(documents=embedder.outputs.documents)
    .depends_on(embedder)
)
milvus_writer_added = rag_wf.flow.add_nodes(vector_store)

Milvus bietet zwei Bereitstellungstypen: MilvusDeploymentType.FILE ist ideal für lokales Prototyping oder Datenspeicherung in kleinem Umfang, wobei die uri auf einen lokalen Dateipfad (z. B. ./milvus.db) gesetzt wird, um Milvus Lite zu nutzen. MilvusDeploymentType.HOST ist für Datenszenarien in großem Maßstab konzipiert. Sie können einen Milvus-Server mit Docker oder Kubernetes bereitstellen oder Zilliz Cloud verwenden, indem Sie die uri und das token auf den Public Endpoint und den API Key in Zilliz Cloud setzen.

5. Den Indizierungs-Workflow ausführen

file_paths = ["./pdf_files/WhatisMilvus.pdf"]
input_data = {
    "files": [BytesIO(open(path, "rb").read()) for path in file_paths],
    "metadata": [{"filename": path} for path in file_paths],
}

inserted_data = rag_wf.run(input_data=input_data)

6. Dokumentabruf-Flow — Initialisieren und Knoten definieren

from dynamiq import Workflow
from dynamiq.connections import (
    OpenAI as OpenAIConnection,
    Milvus as MilvusConnection,
    MilvusDeploymentType,
)
from dynamiq.nodes.embedders import OpenAITextEmbedder
from dynamiq.nodes.retrievers import MilvusDocumentRetriever
from dynamiq.nodes.llms import OpenAI
from dynamiq.prompts import Message, Prompt

# Initialize the workflow
retrieval_wf = Workflow()

# OpenAI connection and text embedder
openai_connection = OpenAIConnection(api_key=os.environ["OPENAI_API_KEY"])
embedder = OpenAITextEmbedder(
    connection=openai_connection,
    model="text-embedding-3-small",
)
embedder_added = retrieval_wf.flow.add_nodes(embedder)

# Milvus-Dokument-Retriever
document_retriever = (
    MilvusDocumentRetriever(
        connection=MilvusConnection(
            deployment_type=MilvusDeploymentType.FILE, uri="./milvus.db"
        ),
        index_name="my_milvus_collection",
        dimension=1536,
        top_k=5,
    )
    .inputs(embedding=embedder.outputs.embedding)
    .depends_on(embedder)
)
milvus_retriever_added = retrieval_wf.flow.add_nodes(document_retriever)

7. Definieren Sie den Prompt und den Antwortgenerator

prompt_template = """
Please answer the question based on the provided context.

Question: {{ query }}

Context:
{% for document in documents %}
- {{ document.content }}
{% endfor %}
"""

prompt = Prompt(messages=[Message(content=prompt_template, role="user")])

answer_generator = (
    OpenAI(
        connection=openai_connection,
        model="gpt-4o",
        prompt=prompt,
    )
    .inputs(
        documents=document_retriever.outputs.documents,
        query=embedder.outputs.query,
    )
    .depends_on([document_retriever, embedder])
)
answer_generator_added = retrieval_wf.flow.add_nodes(answer_generator)

8. Führen Sie den Retrieval-Workflow aus

sample_query = "What is the Advanced Search Algorithms in Milvus?"

result = retrieval_wf.run(input_data={"query": sample_query})

answer = result.output.get(answer_generator.id).get("output", {}).get("content")
print(answer)

Mehr erfahren
- Erste Schritte mit Dynamiq und Milvus — Offizielles Milvus-Tutorial zum Erstellen von RAG mit Dynamiq
- Dynamiq-Dokumentation — Offizielle Dynamiq-Dokumentation
- Dynamiq GitHub Repository — Open-Source-SDK von Dynamiq
- Zilliz Cloud-Dokumentation — Zilliz Cloud-Dokumentation für verwaltetes Milvus
- KI-Apps mit Milvus erstellen: Tutorials & Notebooks — Zilliz-Sammlung von Milvus-Tutorials und Notebooks

Dynamiq and Zilliz Cloud Integration

Was ist Dynamiq

Vorteile der Dynamiq + Zilliz Cloud Integration

So funktioniert die Integration

Schritt-für-Schritt-Anleitung

Mehr erfahren

Verwandte Ressourcen

So bewerten Sie RAG-Anwendungen

Was ist Retrieval Augmented Generation (RAG)?

Optimierung von RAG-Anwendungen