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
# Definir um modelo de prompt de tradução
prompt_template = """
Traduza o seguinte texto para o inglês: {{ text }}
"""
prompt = Prompt(messages=[Message(content=prompt_template, role="user")])
# Configurando o nó do LLM
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
)
# Criar o objeto de fluxo de trabalho
fluxo de trabalho = fluxo de trabalho()
workflow.flow.add_nodes(llm)
# Executar o fluxo de trabalho
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 como E2BConnection
from dynamiq.nodes.agents.react.import ReActAgent
from dynamiq.nodes.tools.e2b_sandbox import E2BInterpreterTool
# Inicializar a ferramenta E2B
e2b_tool = E2BInterpreterTool(connection=E2BConnection(api_key="$API_KEY"))
# configura o LLM
llm = OpenAI(
id="openai",
connection=OpenAIConnection(api_key="$API_KEY"),
model="gpt-4o",
temperature=0.3, max_tokens=1000
max_tokens=1000, )
)
# Criar o agente ReAct
agente = ReActAgent(
nome="react-agent",
llm=llm,
tools=[e2b_tool],
role="Cientista de dados sênior",
max_loops=10, )
)
# Executar o agente
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
Ferramenta de inicialização do #
python_tool = E2BInterpreterTool(connection=E2BConnection(api_key="$E2B_API_KEY"))
search_tool = ScaleSerpTool(connection=ScaleSerpConnection(api_key="$SCALESERP_API_KEY"))
# Inicializar LLM
llm = OpenAI(connection=OpenAIConnection(api_key="$OPENAI_API_KEY")), model="gpt-4o", temperature=0.1)
# Definir o agente
coding_agent = ReActAgent(
name="coding-agent",
llm=llm,
tools=[python_tool],
role="Agente especialista com habilidades de codificação. O objetivo é fornecer a solução para a tarefa de entrada usando as habilidades de engenharia de software Python",
max_loops=15, )
)
planner_agent = ReflectionAgent(
nome="planejador-agente",
llm=llm,
role="Agente especialista com habilidades de planejamento. O objetivo é analisar solicitações complexas e fornecer um plano de ação detalhado.", )
)
search_agent = ReActAgent(
nome="search-agent",
llm=llm,
tools=[search_tool],
role="Agente especialista com habilidades de pesquisa na Web. O objetivo é fornecer a solução para a tarefa de entrada usando habilidades de pesquisa e resumo na Web",
max_loops=10, )
)
# Inicializar o gerenciador de agentes adaptáveis
agent_manager = AdaptiveAgentManager(llm=llm)
# Criar o orquestrador
orchestrator = AdaptiveOrchestrator(
nome="adaptive-orchestrator",
agents=[coding_agent, planner_agent, search_agent],
manager=agent_manager,
)
# Definir a tarefa de entrada
input_task = (
"Use habilidades de codificação para coletar dados sobre os preços das ações da Nvidia e da Intel nos últimos 10 anos, "
"calcular a média por ano para cada empresa e criar uma tabela. Em seguida, elabore um relatório "
"e adicione uma conclusão: o que teria sido melhor se eu tivesse investido $100 há dez anos?"
)
# Executar o orquestrador
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
# Inicializar o fluxo de trabalho
rag_wf = Fluxo de trabalho()
# Conversor de documentos PDF
converter = PyPDFConverter(document_creation_mode="one-doc-per-page")
rag_wf.flow.add_nodes(converter)
Divisor de documentos #
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)
Incorporação do vetor # 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)
Armazenamento do vetor 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)
# Preparar arquivos PDF de entrada
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],
}
# Executar o processo de indexação do 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.agents.simple import SimpleAgent

AGENT_ROLE = "assistente útil, o objetivo é fornecer informações úteis e responder a perguntas"
llm = OpenAI(
connection=OpenAIConnection(api_key="$OPENAI_API_KEY"), model="gpt-4o", "gpt-4o", "gpt-4o", "gpt-4o", "gpt-4o")
model="gpt-4o",
temperature=0.1, )
)

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

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

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

se __name__ == "__main__".
main()