Dynamiq: estrutura de orquestração de corpos inteligentes com suporte a agentes RAG e LLM para simplificar o desenvolvimento de aplicativos de IA

Introdução geral

O Dynamiq é uma estrutura de orquestração de IA de código aberto projetada para aplicativos de IA de agente e Modelagem de Linguagem Grande (LLM). Seu objetivo é simplificar o desenvolvimento de aplicativos orientados por IA, especialmente na área de Geração Aumentada de Recuperação (RAG) e orquestração de agentes LLM. O Dynamiq oferece módulos de recursos avançados e documentação detalhada para ajudar os desenvolvedores a começar rapidamente e criar aplicativos complexos de IA com eficiência.

especificidades

A Dynamiq é uma estrutura inovadora de IA que permite que a IA resolva problemas do mundo real combinando os recursos de raciocínio dos LLMs (o cérebro) com a capacidade de realizar ações específicas (as mãos), permitindo que a IA compreenda tarefas, raciocine e realize ações práticas para resolver problemas do mundo real, assim como os humanos fazem

// Definição de ReAct:

• ReAct é uma estrutura que combina os recursos de raciocínio dos LLMs com a capacidade de realizar operações
• Ele permite que a IA compreenda, planeje e interaja com o mundo real

// Como os agentes ReAct funcionam:
Ele integra dois componentes principais:

• Cérebro (habilidades de raciocínio fornecidas pelo LLM)
• Mãos (capacidade de realizar operações)

// Componentes da estrutura:

• Tarefa
• Agente (inteligência, incluindo LLMs e ferramentas)
• Meio ambiente
• Resposta

// Exemplo prático de aplicação:
Os autores ilustram o fluxo de trabalho do agente ReAct com um cenário que determina se um guarda-chuva é necessário:

• Receber tarefas de usuários perguntando se eles precisam levar um guarda-chuva
• Use a ferramenta para verificar a previsão do tempo
• conduzir análises de inferência
• Dê uma sugestão de resposta

// Estrutura Dynamiq compartilhada por Akshay:
O Dynamiq é uma estrutura abrangente para o desenvolvimento de IA de última geração, focada em simplificar o processo de desenvolvimento de aplicativos de IA, com recursos importantes, como a capacidade de orquestrar e gerenciar aplicativos de IA com base na RAG e o sistema de agentes da LLM.

// Principais características:
All-in-one: uma estrutura completa ("all-in-one") que integra todas as ferramentas e funcionalidades necessárias para desenvolver aplicativos de IA.

Áreas de especialização:

• Organização do sistema RAG
• Gerenciamento do agente LLM
• Otimização do processo de desenvolvimento para aplicativos de IA

Posicionamento:

• Atua como uma estrutura de orquestração, concentrando-se na coordenação e no gerenciamento de componentes individuais de IA
• Desenvolvimento para aplicativos de IA autêntica
• Simplificando a complexidade para os desenvolvedores ao criar aplicativos de IA

Lista de funções

• Instalação e configuraçãoGuia de instalação: fornece um guia de instalação detalhado para dar suporte a ambientes Python.
• Documentação e exemplosDocumentação rica e código de amostra para ajudar os usuários a começar rapidamente.
• Processo simples de LLMFornecer exemplos simples de fluxo de trabalho do LLM para facilitar a compreensão e o uso.
• Agente ReActAgente para dar suporte a tarefas complexas de codificação com o interpretador de código E2B integrado.
• programação multiagenteSuporte para cooperação entre vários agentes e soluções para tarefas complexas.
• Indexação e recuperação de documentos RAGSuporte ao pré-processamento, à incorporação de vetores e ao armazenamento de documentos PDF, bem como à recuperação de documentos relacionados e à resposta a perguntas.
• Chatbot com memóriaChatbot: um chatbot simples que suporta o armazenamento e a recuperação do histórico de conversas.

Usando a Ajuda

Instalação e configuração

1. Instalação do PythonVerifique se o Python está instalado em seu computador.
2. Instalação do Dynamiq::

   pip install dynamiq
   

   Ou criar a partir do código-fonte:

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

exemplo de uso

Processo simples de LLM

Abaixo está um exemplo simples de fluxo de trabalho do 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)

Agente ReAct

A seguir, um exemplo de um agente ReAct que oferece suporte a tarefas de codificação complexas:

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

programação multiagente

A seguir, um exemplo de vários agentes trabalhando juntos:

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

Indexação e recuperação de documentos RAG

O Dynamiq oferece suporte ao Retrieval Augmentation Generation (RAG), que pode ser obtido seguindo as etapas abaixo:

1. Pré-processamento de documentosConversão de arquivos PDF de entrada em embeddings vetoriais e armazenamento em um banco de dados vetorial.
2. pesquisa de documentosRecuperação de documentos relevantes e geração de respostas com base nas consultas do usuário.

Abaixo está um exemplo simples de um fluxo de trabalho 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 com memória

Aqui está um exemplo de um chatbot simples com memória:

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