Dynamiq : Cadre d'orchestration de corps intelligents avec support d'agents RAG et LLM pour simplifier le développement d'applications d'IA

Introduction générale

Dynamiq est un cadre d'orchestration d'IA open source conçu pour l'IA des agents et les applications de modélisation des grands langages (LLM). Dynamiq fournit des modules riches en fonctionnalités et une documentation détaillée pour aider les développeurs à démarrer rapidement et à construire des applications d'IA complexes de manière efficace.

spécificités

Dynamiq est un cadre d'IA innovant qui permet à l'IA de résoudre des problèmes du monde réel en combinant les capacités de raisonnement des LLM (le cerveau) avec la capacité d'effectuer des actions spécifiques (les mains), ce qui permet à l'IA de comprendre les tâches, de raisonner et de prendre des mesures pratiques pour résoudre des problèmes du monde réel, tout comme le font les humains.

// Définition du ReAct :

• ReAct est un cadre qui combine les capacités de raisonnement des LLM avec la possibilité d'effectuer des opérations
• Elle permet à l'IA de comprendre, de planifier et d'interagir avec le monde réel.

// Le fonctionnement des agents du ReAct :
Il intègre deux éléments clés :

• Cerveau (capacités de réflexion fournies par le LLM)
• Mains (capacité à effectuer des opérations)

// Composants du cadre :

• Tâche
• Agent (intelligence, y compris LLM et outils)
• Environnement
• Réponse

// Exemple d'application pratique :
Les auteurs illustrent le flux de travail de l'agent ReAct par un scénario qui détermine si un parapluie est nécessaire :

• Recevoir des tâches de la part d'utilisateurs demandant s'ils doivent apporter un parapluie
• Utiliser l'outil pour vérifier le bulletin météorologique
• effectuer des analyses d'inférence
• Donner une proposition de réponse

// Cadre Dynamiq partagé par Akshay :
Dynamiq est un cadre complet pour le développement de l'IA de nouvelle génération, axé sur la rationalisation du processus de développement des applications d'IA, avec des caractéristiques clés telles que la capacité d'orchestrer et de gérer les applications d'IA sur la base de l'architecture de l'IA. RAG et le système d'agents de LLM.

// Caractéristiques principales :
Tout-en-un : un cadre unique ("tout-en-un") qui intègre tous les outils et fonctionnalités nécessaires au développement d'applications d'IA.

Domaines d'expertise :

• Organisation du système RAG
• Gestion de l'agent LLM
• Optimisation du processus de développement pour les applications de l'IA

Positionnement :

• Agit comme un cadre d'orchestration, en se concentrant sur la coordination et la gestion des composants individuels de l'intelligence artificielle.
• Développement d'applications d'IA agentique
• Simplifier la complexité pour les développeurs lors de la création d'applications d'IA

Liste des fonctions

• Installation et configurationGuide d'installation : fournit un guide d'installation détaillé pour prendre en charge les environnements Python.
• Documentation et exemplesLes utilisateurs peuvent se servir de l'application comme d'un outil d'aide à la décision : une documentation riche et des exemples de code pour aider les utilisateurs à démarrer rapidement.
• Processus simple de LLMLes exemples de flux de travail LLM sont simples et facilitent la compréhension et l'utilisation.
• Agent ReActAgent de codage : Agent de codage complexe avec interpréteur de code E2B intégré.
• planification multi-agentsLa recherche de solutions pour des tâches complexes : soutien à la coopération multi-agents et solutions pour des tâches complexes.
• Indexation et recherche de documents RAGIl prend en charge le prétraitement, l'incorporation de vecteurs et le stockage de documents PDF, ainsi que la recherche de documents connexes et la réponse à des questions.
• Chatbot avec mémoire: Un simple chatbot qui prend en charge le stockage et l'extraction de l'historique des conversations.

Utiliser l'aide

Installation et configuration

1. Installation de PythonPour ce faire, vous devez vous assurer que Python est installé sur votre ordinateur.
2. Installation de Dynamiq: :

   pip install dynamiq
   

   Ou construire à partir du code source :

   git clone https://github.com/dynamiq-ai/dynamiq.git
   cd dynamiq
   poetry install
   

exemple d'utilisation

Processus simple de LLM

Vous trouverez ci-dessous un exemple simple de flux de travail LLM :

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)

Agent ReAct

Voici un exemple d'agent ReAct qui prend en charge des tâches de codage complexes :

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"))

planification multi-agents

Voici un exemple de collaboration entre plusieurs agents :

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"))

Indexation et recherche de documents RAG

Dynamiq supporte la Génération d'Augmentation de Récupération (RAG), qui peut être réalisée en suivant les étapes ci-dessous :

1. Prétraitement des documentsLe système de gestion des données vectorielles : convertit les fichiers PDF d'entrée en encastrements vectoriels et les stocke dans une base de données vectorielles.
2. recherche de documentsLes services d'aide à la décision : Récupérer les documents pertinents et générer des réponses en fonction des requêtes de l'utilisateur.

Vous trouverez ci-dessous un exemple simple d'un flux de travail RAG :

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 avec mémoire

Voici un exemple de chatbot simple avec mémoire :

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()