Dynamiq: Intelligent Body Orchestration Framework mit RAG- und LLM-Agent-Unterstützung zur Vereinfachung der Entwicklung von KI-Anwendungen

Allgemeine Einführung

Dynamiq ist ein quelloffenes KI-Orchestrierungs-Framework, das für KI-Agenten und Large Language Modelling (LLM)-Anwendungen entwickelt wurde. Es zielt darauf ab, die Entwicklung von KI-gesteuerten Anwendungen zu vereinfachen, insbesondere im Bereich der Retrieval Augmented Generation (RAG) und der Orchestrierung von LLM-Agenten.Dynamiq bietet reichhaltige Funktionsmodule und eine detaillierte Dokumentation, um Entwicklern einen schnellen Einstieg zu ermöglichen und komplexe KI-Anwendungen effizient zu erstellen.

Besonderheiten

Dynamiq ist ein innovatives KI-Framework, das KI in die Lage versetzt, reale Probleme zu lösen, indem es die Denkfähigkeiten von LLMs (dem Gehirn) mit der Fähigkeit kombiniert, bestimmte Handlungen auszuführen (den Händen). So kann KI Aufgaben verstehen, logisch denken und praktische Maßnahmen ergreifen, um reale Probleme zu lösen, genau wie Menschen!

// Definition von ReAct:

• ReAct ist ein Rahmenwerk, das die Argumentationsfähigkeiten von LLMs mit der Fähigkeit kombiniert, Operationen durchzuführen
• Sie ermöglicht es der KI, die reale Welt zu verstehen, zu planen und mit ihr zu interagieren.

// Wie ReAct-Agenten arbeiten:
Es umfasst zwei Schlüsselkomponenten:

• Gehirn (durch LLM vermittelte Denkfähigkeiten)
• Hände (Fähigkeit zur Durchführung von Operationen)

// Rahmenkomponenten:

• Aufgabe
• Agent (Intelligenz, einschließlich LLMs und Tools)
• Umwelt
• Antwort

// Praktisches Anwendungsbeispiel:
Die Autoren veranschaulichen den Arbeitsablauf des ReAct-Agenten anhand eines Szenarios, in dem ermittelt wird, ob ein Regenschirm erforderlich ist:

• Aufgaben von Nutzern erhalten, die fragen, ob sie einen Regenschirm mitbringen müssen
• Verwenden Sie das Tool, um den Wetterbericht zu prüfen
• Inferenzanalysen durchführen
• Geben Sie einen Antwortvorschlag

// Dynamiq-Framework von Akshay:
Dynamiq ist ein umfassendes Framework für die KI-Entwicklung der nächsten Generation, das sich darauf konzentriert, den Entwicklungsprozess für KI-Anwendungen zu rationalisieren. RAG und das Agenten-System von LLM.

// Hauptmerkmale:
All-in-one: Ein All-in-One"-Framework, das alle für die Entwicklung von KI-Anwendungen erforderlichen Tools und Funktionen integriert.

Fachgebiete:

• Organisation des RAG-Systems
• Verwaltung des LLM-Agenten
• Optimierung des Entwicklungsprozesses für KI-Anwendungen

Positionierung:

• fungiert als Orchestrierungsrahmen, der sich auf die Koordinierung und Verwaltung der einzelnen KI-Komponenten konzentriert
• Entwicklung für agentenbasierte KI-Anwendungen
• Vereinfachung der Komplexität für Entwickler bei der Entwicklung von KI-Anwendungen

Funktionsliste

• Installation und KonfigurationBietet eine detaillierte Installationsanleitung zur Unterstützung von Python-Umgebungen.
• Dokumentation und BeispieleUmfangreiche Dokumentation und Beispielcode für einen schnellen Einstieg.
• Einfacher LLM-ProzessEinfache Beispiele für LLM-Arbeitsabläufe zum leichteren Verständnis und zur leichteren Nutzung bereitstellen.
• ReAct AgentAgent zur Unterstützung komplexer Kodierungsaufgaben mit integriertem E2B-Code-Interpreter.
• Multi-Agenten-PlanungUnterstützung für die Zusammenarbeit mehrerer Agenten und Lösungen für komplexe Aufgaben.
• RAG-Dokumentenindizierung und -wiederauffindungUnterstützt die Vorverarbeitung, Vektoreinbettung und Speicherung von PDF-Dokumenten sowie die Suche nach verwandten Dokumenten und die Beantwortung von Fragen.
• Chatbot mit GedächtnisEin einfacher Chatbot, der die Speicherung und den Abruf des Gesprächsverlaufs unterstützt.

Hilfe verwenden

Installation und Konfiguration

1. Installation von PythonStellen Sie sicher, dass Sie Python auf Ihrem Computer installiert haben.
2. Installieren von Dynamiq::

   pip install dynamiq
   

   Oder erstellen Sie aus dem Quellcode:

   git clone https://github.com/dynamiq-ai/dynamiq.git
   cd dynamiq
   dichtung installieren
   

Anwendungsbeispiel

Einfacher LLM-Prozess

Im Folgenden finden Sie ein einfaches Beispiel für einen LLM-Arbeitsablauf:

from dynamiq.nodes.llms.openai importieren OpenAI
from dynamiq.connections import OpenAI as OpenAIConnection
from dynamiq importieren Arbeitsablauf
from dynamiq.prompts import Prompt, Nachricht
# Definieren Sie eine Vorlage für einen Übersetzungsprompt
prompt_template = """
Übersetze den folgenden Text ins Englische: {{ text }}
"""
prompt = Prompt(messages=[Message(content=prompt_template, role="user")])
# Einrichten des LLM-Knotens
llm = OpenAI(
id="openai",
connection=OpenAIConnection(api_key="$OPENAI_API_KEY"),
model="gpt-4o",
temperature=0.3, max_tokens=1000
max_tokens=1000, prompt=prompt
prompt=prompt
)
# Erstellen Sie das Workflow-Objekt
Arbeitsablauf = Arbeitsablauf()
workflow.flow.add_nodes(llm)
# Ausführen des Workflows
result = workflow.run(input_data={"text": "Hola Mundo!"})
print(result.output)

ReAct Agent

Im Folgenden finden Sie ein Beispiel für einen ReAct-Agenten, der komplexe Codierungsaufgaben unterstützt:

from dynamiq.nodes.llms.openai importieren OpenAI
from dynamiq.connections import OpenAI as OpenAIConnection, E2B as E2BConnection
from dynamiq.nodes.agents.react.import ReActAgent
from dynamiq.nodes.tools.e2b_sandbox import E2BInterpreterTool
# Initialisieren Sie das E2B-Tool
e2b_tool = E2BInterpreterTool(connection=E2BConnection(api_key="$API_KEY"))
# richtet den LLM ein
llm = OpenAI(
id="openai",
connection=OpenAIConnection(api_key="$API_KEY"),
model="gpt-4o",
temperature=0.3, max_tokens=1000
max_tokens=1000, )
)
# Erstellen Sie den ReAct-Agenten
agent = ReActAgent(
name="react-agent",
llm=llm,
tools=[e2b_tool],
role="Senior Datenwissenschaftler",
max_loops=10, )
)
# Ausführen des Agenten
result = agent.run(input_data={"input": "Addiere die ersten 10 Zahlen und sage, ob das Ergebnis eine Primzahl ist."}))
print(result.output.get("Inhalt"))

Multi-Agenten-Planung

Im Folgenden wird ein Beispiel für die Zusammenarbeit mehrerer Agenten gegeben:

from dynamiq.connections import OpenAI as OpenAIConnection, ScaleSerp as ScaleSerpConnection, E2B as E2BConnection
von dynamiq.nodes.llms importieren OpenAI
von dynamiq.nodes.agents.orchestrators.adaptive importieren AdaptiveOrchestrator
from dynamiq.nodes.agents.orchestrators.adaptive_manager import AdaptiveAgentManager
from dynamiq.nodes.agents.react.import ReActAgent
from dynamiq.nodes.agents.reflection.import ReflectionAgent
from dynamiq.nodes.tools.e2b_sandbox import E2BInterpreterTool
from dynamiq.nodes.tools.scale_serp importieren ScaleSerpTool
# Initialisierungs-Werkzeug
python_tool = E2BInterpreterTool(connection=E2BConnection(api_key="$E2B_API_KEY"))
search_tool = ScaleSerpTool(connection=ScaleSerpConnection(api_key="$SCALESERP_API_KEY"))
# LLM initialisieren
llm = OpenAI(connection=OpenAIConnection(api_key="$OPENAI_API_KEY"), model="gpt-4o", temperature=0.1)
# Definieren Sie den Agenten
coding_agent = ReActAgent(
name="coding-agent",
llm=llm,
tools=[python_tool],
role="Experten-Agent mit Programmierkenntnissen, der die Aufgabe mit Hilfe von Python-Software-Engineering-Kenntnissen lösen soll.",
max_loops=15, )
)
planner_agent = ReflectionAgent(
name="planner-agent",
llm=llm,
role="Expertenagent mit Planungsfähigkeiten, der komplexe Anfragen analysiert und einen detaillierten Aktionsplan erstellt", )
)
search_agent = ReActAgent(
name="such-agent",
llm=llm,
tools=[search_tool],
role="Expertenagent mit Web-Suchfähigkeiten. Ziel ist es, die Lösung der Eingabeaufgabe mithilfe von Web-Such- und Zusammenfassungsfähigkeiten bereitzustellen.",
max_loops=10, )
)
# Initialisierung des adaptiven Agentenmanagers
agent_manager = AdaptiveAgentManager(llm=llm)
# Erstellen des Orchestrators
orchestrator = AdaptiveOrchestrator(
name="adaptive-orchestrator",
agents=[coding_agent, planner_agent, search_agent],
manager=agent_manager,
)
# Definieren Sie die Eingabeaufgabe
input_task = (
"Verwenden Sie Programmierkenntnisse, um Daten über die Aktienkurse von Nvidia und Intel für die letzten 10 Jahre zu sammeln, "
"berechne den Durchschnitt pro Jahr für jedes Unternehmen und erstelle eine Tabelle. "
"und füge eine Schlussfolgerung hinzu: Was wäre besser gewesen, wenn ich vor zehn Jahren $100 investiert hätte?"
)
# Starten Sie den Orchestrator
result = orchestrator.run(input_data={"input": input_task})
print(result.output.get("Inhalt"))

RAG-Dokumentenindizierung und -wiederauffindung

Dynamiq unterstützt die Retrieval Augmentation Generation (RAG), die mit den nachstehenden Schritten erreicht werden kann:

1. Vorverarbeitung von DokumentenKonvertierung von PDF-Eingabedateien in Vektoreinbettungen und deren Speicherung in einer Vektordatenbank.
2. DokumentensucheAbrufen relevanter Dokumente und Generierung von Antworten auf der Grundlage von Benutzeranfragen.

Nachstehend finden Sie ein einfaches Beispiel für einen RAG-Arbeitsablauf:

von io importieren BytesIO
von dynamiq importieren Workflow
from dynamiq.connections importiere OpenAI als OpenAIConnection, Pinecone als PineconeConnection
from dynamiq.nodes.converters importieren PyPDFConverter
from dynamiq.nodes.splitters.document importieren DocumentSplitter
from dynamiq.nodes.embedders importieren OpenAIDocumentEmbedder
from dynamiq.nodes.writers importieren PineconeDocumentWriter
# Arbeitsablauf initialisieren
rag_wf = Workflow()
# PDF-Dokument-Konverter
converter = PyPDFConverter(document_creation_mode="one-doc-per-page")
rag_wf.flow.add_nodes(Konverter)
# Dokumentensplitter
document_splitter = (
DocumentSplitter(split_by="sentence", split_length=10, split_overlap=1)
.inputs(documents=converter.outputs.documents)
.depends_on(konverter)
)
rag_wf.flow.add_nodes(dokument_splitter)
# OpenAI Vektor-Einbettung
embedder = (
OpenAIDocumentEmbedder(connection=OpenAIConnection(api_key="$OPENAI_API_KEY"), model="text-embedding-3-small")
.inputs(documents=document_splitter.outputs.documents)
.depends_on(dokument_splitter)
)
rag_wf.flow.add_nodes(einbetter)
# Pinecone-Vektorspeicher
vector_store = (
PineconeDocumentWriter(connection=PineconeConnection(api_key="$PINECONE_API_KEY"), index_name="default", dimension=1536)
.inputs(documents=embedder.outputs.documents)
.depends_on(embedder)
)
rag_wf.flow.add_nodes(vector_store)
# Vorbereiten der PDF-Eingabedateien
file_paths = ["beispiel.pdf"]
input_data = {
"files": [BytesIO(open(path, "rb").read()) for path in file_paths],
"metadata": [{"filename": path} for path in file_paths],
}
# Starten Sie den RAG-Indizierungsprozess
rag_wf.run(input_data=input_data)

Chatbot mit Gedächtnis

Hier ist ein Beispiel für einen einfachen Chatbot mit Speicher:

from dynamiq.connections import OpenAI as OpenAIConnection
from dynamiq.memory import Speicher
from dynamiq.memory.backend.in_memory importieren InMemory
from dynamiq.nodes.agents.simple importieren SimpleAgent
from dynamiq.nodes.agents.simple import SimpleAgent

AGENT_ROLE = "hilfreicher Assistent, Ziel ist es, nützliche Informationen zu liefern und Fragen zu beantworten"
llm = OpenAI(
connection=OpenAIConnection(api_key="$OPENAI_API_KEY"), model="gpt-4o", "gpt-4o", "gpt-4o", "gpt-4o")
model="gpt-4o",
temperatur=0.1, )
)

memory = Speicher(backend=InMemory())
agent = SimpleAgent(
name="Agent",
llm=llm,
name="Agent", llm=llm, role=AGENT_ROLE, id="agent",
id="Agent",
memory=memory, )
)

def main().
print("Willkommen im KI-Chat! (Zum Beenden 'exit' eingeben)")
while True: user_input = input("Sie:")
user_input = input("Sie: ")
if user_input.lower() == "exit": if user_input.lower() == "exit".
Wenn user_input.lower() == "exit": break

response = agent.run({"input": user_input})
response_content = response.output.get("Inhalt")
print(f "AI: {Antwort_Inhalt}")

if __name__ == "__main__".
main()

Der Leitfaden für Laien zum Einstieg in die KI

Hilft Ihnen, die Nutzung von KI-Tools kostengünstig und von Null an zu erlernen.KI ist, wie Bürosoftware, eine wesentliche Fähigkeit für jeden. Die Beherrschung von KI verschafft Ihnen einen Vorteil bei der Stellensuche und die Hälfte des Aufwands bei Ihrer zukünftigen Arbeit und Ihrem Studium.

Details ansehen>