Dynamiq: Intelligent Body Orchestration Framework mit RAG- und LLM-Agentenunterstützung zur Vereinfachung der KI-Anwendungsentwicklung

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), wodurch KI in die Lage versetzt wird, Aufgaben zu verstehen, zu denken und praktische Maßnahmen zu ergreifen, um reale Probleme zu lösen, genau wie Menschen es tun

// 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 LLM und Werkzeuge)
• 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
   poetry install
   

Anwendungsbeispiel

Einfacher LLM-Prozess

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

from dynamiq.nodes.llms.openai import OpenAI
from dynamiq.connections import OpenAI as OpenAIConnection
from dynamiq import Workflow
from dynamiq.prompts import Prompt, Message
# 定义翻译提示模板
prompt_template = """
Translate the following text into English: {{ text }}
"""
prompt = Prompt(messages=[Message(content=prompt_template, role="user")])
# 设置LLM节点
llm = OpenAI(
id="openai",
connection=OpenAIConnection(api_key="$OPENAI_API_KEY"),
model="gpt-4o",
temperature=0.3,
max_tokens=1000,
prompt=prompt
)
# 创建工作流对象
workflow = Workflow()
workflow.flow.add_nodes(llm)
# 运行工作流
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 import 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
# 初始化E2B工具
e2b_tool = E2BInterpreterTool(connection=E2BConnection(api_key="$API_KEY"))
# 设置LLM
llm = OpenAI(
id="openai",
connection=OpenAIConnection(api_key="$API_KEY"),
model="gpt-4o",
temperature=0.3,
max_tokens=1000,
)
# 创建ReAct代理
agent = ReActAgent(
name="react-agent",
llm=llm,
tools=[e2b_tool],
role="Senior Data Scientist",
max_loops=10,
)
# 运行代理
result = agent.run(input_data={"input": "Add the first 10 numbers and tell if the result is prime."})
print(result.output.get("content"))

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
from dynamiq.nodes.llms import OpenAI
from dynamiq.nodes.agents.orchestrators.adaptive import 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 import ScaleSerpTool
# 初始化工具
python_tool = E2BInterpreterTool(connection=E2BConnection(api_key="$E2B_API_KEY"))
search_tool = ScaleSerpTool(connection=ScaleSerpConnection(api_key="$SCALESERP_API_KEY"))
# 初始化LLM
llm = OpenAI(connection=OpenAIConnection(api_key="$OPENAI_API_KEY"), model="gpt-4o", temperature=0.1)
# 定义代理
coding_agent = ReActAgent(
name="coding-agent",
llm=llm,
tools=[python_tool],
role="Expert agent with coding skills. Goal is to provide the solution to the input task using Python software engineering skills.",
max_loops=15,
)
planner_agent = ReflectionAgent(
name="planner-agent",
llm=llm,
role="Expert agent with planning skills. Goal is to analyze complex requests and provide a detailed action plan.",
)
search_agent = ReActAgent(
name="search-agent",
llm=llm,
tools=[search_tool],
role="Expert agent with web search skills. Goal is to provide the solution to the input task using web search and summarization skills.",
max_loops=10,
)
# 初始化自适应代理管理器
agent_manager = AdaptiveAgentManager(llm=llm)
# 创建编排器
orchestrator = AdaptiveOrchestrator(
name="adaptive-orchestrator",
agents=[coding_agent, planner_agent, search_agent],
manager=agent_manager,
)
# 定义输入任务
input_task = (
"Use coding skills to gather data about Nvidia and Intel stock prices for the last 10 years, "
"calculate the average per year for each company, and create a table. Then craft a report "
"and add a conclusion: what would have been better if I had invested $100 ten years ago?"
)
# 运行编排器
result = orchestrator.run(input_data={"input": input_task})
print(result.output.get("content"))

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:

from io import BytesIO
from dynamiq import Workflow
from dynamiq.connections import OpenAI as OpenAIConnection, Pinecone as PineconeConnection
from dynamiq.nodes.converters import PyPDFConverter
from dynamiq.nodes.splitters.document import DocumentSplitter
from dynamiq.nodes.embedders import OpenAIDocumentEmbedder
from dynamiq.nodes.writers import PineconeDocumentWriter
# 初始化工作流
rag_wf = Workflow()
# PDF文档转换器
converter = PyPDFConverter(document_creation_mode="one-doc-per-page")
rag_wf.flow.add_nodes(converter)
# 文档拆分器
document_splitter = (
DocumentSplitter(split_by="sentence", split_length=10, split_overlap=1)
.inputs(documents=converter.outputs.documents)
.depends_on(converter)
)
rag_wf.flow.add_nodes(document_splitter)
# OpenAI向量嵌入
embedder = (
OpenAIDocumentEmbedder(connection=OpenAIConnection(api_key="$OPENAI_API_KEY"), model="text-embedding-3-small")
.inputs(documents=document_splitter.outputs.documents)
.depends_on(document_splitter)
)
rag_wf.flow.add_nodes(embedder)
# Pinecone向量存储
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)
# 准备输入PDF文件
file_paths = ["example.pdf"]
input_data = {
"files": [BytesIO(open(path, "rb").read()) for path in file_paths],
"metadata": [{"filename": path} for path in file_paths],
}
# 运行RAG索引流程
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 Memory
from dynamiq.memory.backend.in_memory import InMemory
from dynamiq.nodes.agents.simple import SimpleAgent
from dynamiq.nodes.llms import OpenAI

AGENT_ROLE = "helpful assistant, goal is to provide useful information and answer questions"
llm = OpenAI(
connection=OpenAIConnection(api_key="$OPENAI_API_KEY"),
model="gpt-4o",
temperature=0.1,
)

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

def main():
print("Welcome to the AI Chat! (Type 'exit' to end)")
while True:
user_input = input("You: ")
if user_input.lower() == "exit":
break

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

if __name__ == "__main__":
main()