ZeroGraph: uma estrutura leve de programação de agentes de IA

Introdução geral

O ZeroGraph é uma estrutura leve de código aberto projetada para a programação de agentes de IA, desenvolvida em TypeScript, com apenas 300 linhas de código (~10 KB) e sem dependências. Ele se baseia na arquitetura de nós (Node) e de fluxo (Flow), que oferece suporte à construção rápida de um fluxo de trabalho eficiente de agente de IA. O ZeroGraph oferece segurança de tipo e forte suporte a IDE, adequado para que os desenvolvedores criem desde simples saudações até complexas tarefas de colaboração com vários agentes. O projeto está licenciado sob a licença MIT, está bem documentado com exemplos e é fácil de começar a usar, o que o torna adequado para uma ampla gama de cenários de pesquisa e desenvolvimento.

Lista de funções

• Arquitetura de nós e fluxos Processamento modular de tarefas e orquestração de fluxos por meio das classes Node e Flow.
• Design leve Apenas 300 linhas de código, sem dependências, executado com eficiência e sem dependência de fornecedor.
• segurança de tipo Suporte nativo ao TypeScript com verificação completa de tipos e dicas do IDE.
• Suporte a lotes Processamento de várias partes de dados por meio de um BatchNode: o processamento de várias partes de dados por meio de um BatchNode aumenta a eficiência do processamento.
• operação assíncrona Suporte ao AsyncNode, adequado para tarefas assíncronas, como solicitações de rede.
• Programação de proxy Suporte para fluxos de trabalho complexos, como colaboração multiagente, geração de aumento de recuperação (RAG), etc.
• Exemplos ricos Código de amostra: fornece código de amostra do básico ao avançado, como saudações, pesquisa e colaboração com vários agentes.

Usando a Ajuda

Processo de instalação

O ZeroGraph foi desenvolvido em TypeScript e requer a instalação do Node.js e do npm/yarn:

1. Preparação ambiental
   • Certifique-se de que o Node.js (16+ recomendado) e o npm/yarn estejam instalados.
   • Validar o ambiente:

     node -v
     npm -v
     

   • Opcional: instale o TypeScript para dar suporte à verificação de tipos:

     npm install -g typescript
     

2. Instalar o ZeroGraph
   Use o npm para instalar:

   npm install @u0z/zero-graph
   

   ou usar fios:

   yarn add @u0z/zero-graph
   

3. Verificar a instalação
   Crie um arquivo TypeScript simples (por exemplo test.ts) e execute o código a seguir:

   import { Node, Flow } from '@u0z/zero-graph';
   console.log("ZeroGraph installed successfully!");
   

   Compilar e executar:

   tsc test.ts
   node test.js
   

   Se for exibida uma mensagem de sucesso, a instalação foi feita corretamente.

Funções principais

1. nó e fluxo

No coração do ZeroGraph estão o Node e o Flow, com o Node lidando com uma única tarefa e o Flow orquestrando vários nós. Etapas:

• Definição de nós Criar uma herança Node que contém a classe prep(Preparar dados),exec(lógica de execução) e post(armazenar resultados). Exemplo:

import { Node, Flow } from '@u0z/zero-graph';
class GreetingNode extends Node {
prep(shared: any): string {
return shared.name || 'World';
}
exec(name: string): string {
return `Hello, ${name}!`;
}
post(shared: any, prepRes: string, execRes: string): void {
shared.greeting = execRes;
}
}

• Criação de fluxos Conecte o nó ao Flow e execute-o:

const flow = new Flow(new GreetingNode());
const shared = { name: 'TypeScript' };
flow.run(shared);
console.log(shared.greeting); // 输出: Hello, TypeScript!

2. processamento em lote

O BatchNode é adequado para processar várias partes de dados. Etapas da operação:

• Definição de nós de lote ::

class BatchProcessor extends BatchNode {
exec(item: any): any {
return `Processed: ${item}`;
}
}

• Execução de um fluxo em lote ::

const batchFlow = new BatchFlow(new BatchProcessor());
const items = ['item1', 'item2', 'item3'];
batchFlow.run(items).then(results => console.log(results));

3. operações assíncronas (suporte assíncrono)

O AsyncNode oferece suporte a tarefas assíncronas, como chamadas de API. Etapas da operação:

• Definição de nós assíncronos ::

class AsyncProcessor extends AsyncNode {
async execAsync(input: any): Promise<any> {
return new Promise(resolve => setTimeout(() => resolve(`Processed: ${input}`), 1000));
}
}

• Execução de um fluxo assíncrono ::

const asyncFlow = new AsyncFlow(new AsyncProcessor());
const shared = { input: 'test' };
asyncFlow.runAsync(shared).then(() => console.log(shared.result));

4. colaboração multiagente

O ZeroGraph suporta fluxos de trabalho de vários agentes. Etapas operacionais:

• Definição de vários nós Criar várias classes de nó para lidar com diferentes tarefas.
• nó de conexão : através de next especifica a lógica de salto entre os nós:

class NodeA extends Node {
exec(input: any): string {
return input ? 'success' : 'error';
}
}
class NodeB extends Node {
exec(input: any): string {
return 'Task B done';
}
}
const nodeA = new NodeA();
const nodeB = new NodeB();
nodeA.next(nodeB, 'success');
const flow = new Flow(nodeA);
flow.run({ input: true });

5. uso de código de amostra

O ZeroGraph fornece uma grande quantidade de exemplos na seção examples/ Catálogo. Procedimento operacional:

• armazém de clones ::

git clone https://github.com/u-0-z/zero-graph.git
cd zero-graph

• exemplo de execução : Acesso examples/ para executar um exemplo específico:

cd examples/hello-world
npm install
ts-node index.ts

• Os exemplos incluem saudações básicas (hello-world), agentes de pesquisa (agent), geração de conteúdo (workflow), processamento em lote (batch), operações assíncronas (async), geração de aprimoramento de recuperação (rag) e colaboração com vários agentes (multi-agent).

advertência

• Configuração de TypeScript Verifique se o projeto contém tsconfig.jsonConfigurações recomendadas:

{
"compilerOptions": {
"target": "ES6",
"module": "commonjs",
"strict": true
}
}

• Acesso ao documento Documentação completa: A documentação completa está localizada em docs/ Catálogo que abrange os principais conceitos, padrões de design e referências de API.
• Suporte à comunidade Verifique os problemas do GitHub ou envie um novo problema se você encontrar problemas.

cenário do aplicativo

1. Prototipagem rápida de agentes de IA
   O design leve do ZeroGraph se presta à rápida criação de protótipos de agentes de IA. Por exemplo, os desenvolvedores podem criar um agente de pesquisa que combina APIs da Web para permitir a recuperação de informações em tempo real.
2. Fluxos de trabalho automatizados
   Em cenários de geração de conteúdo ou processamento de dados, o ZeroGraph orquestra fluxos de trabalho de vários nós, como a automação da geração de artigos ou o processamento de dados em massa.
3. Educação e pesquisa
   Estudantes e pesquisadores podem aprender TypeScript e programação de agentes de IA com o ZeroGraph, com código de amostra adequado para ensino e experimentação.

QA

1. Qual é a diferença entre o ZeroGraph e o LangChain?
   O ZeroGraph tem apenas 300 linhas de código e se concentra na programação leve de agentes de IA, sem dependências e com TypeScript nativo, enquanto o LangChain é mais complexo e tem uma grande quantidade de código (405 mil linhas), o que o torna adequado para grandes projetos, mas com sobrecarga de desempenho.
2. Precisa de experiência em TypeScript?
   O conhecimento básico de JavaScript é suficiente para começar, e os recursos de segurança de tipo do TypeScript são solicitados automaticamente pelo IDE, reduzindo a curva de aprendizado.
3. Como faço para depurar meu código?
   Use um IDE, como o VS Code, em conjunto com uma ferramenta de depuração de TypeScript. Executar ts-node Execute o código e visualize a saída do console ou o log.
4. Quais tarefas complexas são suportadas?
   Oferece suporte à colaboração de vários agentes, geração aprimorada por recuperação (RAG) e fluxos de trabalho assíncronos para cenários como pesquisa, geração de conteúdo e muito mais.