ZeroGraph: ein leichtgewichtiges Programmiergerüst für KI-Agenten

Allgemeine Einführung

ZeroGraph ist ein leichtgewichtiges Open-Source-Framework für die Programmierung von KI-Agenten, entwickelt in TypeScript, mit nur 300 Zeilen Code (~10KB) und ohne Abhängigkeiten. Es basiert auf einer Knoten- (Node) und Fluss-Architektur (Flow), die den schnellen Aufbau eines effizienten KI-Agenten-Workflows unterstützt. ZeroGraph bietet Typsicherheit und starke IDE-Unterstützung, geeignet für Entwickler, um von einfachen Begrüßungen bis hin zu komplexen Multi-Agenten-Kollaborationsaufgaben zu erstellen. Das Projekt ist unter der MIT-Lizenz lizenziert, gut dokumentiert und mit Beispielen versehen, so dass es für ein breites Spektrum von Forschungs- und Entwicklungsszenarien geeignet ist.

Funktionsliste

• Knoten- und Flussarchitektur Modulares Task-Processing und Flow-Orchestrierung durch Node- und Flow-Klassen.
• Leichte Konstruktion Nur 300 Zeilen Code, keine Abhängigkeiten, läuft effizient und ohne Herstellerbindung.
• Typensicherheit Native TypeScript-Unterstützung mit vollständiger Typüberprüfung und IDE-Hinweisen.
• Batch-Unterstützung BatchNode: Die Verarbeitung mehrerer Daten über einen BatchNode verbessert die Verarbeitungseffizienz.
• asynchroner Betrieb AsyncNode-Unterstützung, geeignet für asynchrone Aufgaben wie Netzanfragen.
• Proxy-Programmierung Unterstützung komplexer Arbeitsabläufe wie Multi-Agenten-Kollaboration, Retrieval Augmentation Generation (RAG), etc.
• Reichhaltige Beispiele Bietet Beispielcode von grundlegenden bis zu fortgeschrittenen Funktionen wie Begrüßung, Suche und Zusammenarbeit mehrerer Agenten.

Hilfe verwenden

Einbauverfahren

ZeroGraph wurde in TypeScript entwickelt und erfordert die Installation von Node.js und npm/yarn, hier sind die Installationsschritte:

1. Vorbereitung der Umwelt
   • Stellen Sie sicher, dass Node.js (16+ empfohlen) und npm/yarn installiert sind.
   • Validieren Sie die Umgebung:

     node -v
     npm -v
     

   • Optional: Installieren Sie TypeScript, um die Typüberprüfung zu unterstützen:

     npm install -g typescript
     

2. ZeroGraph installieren
   Verwenden Sie npm zur Installation:

   npm install @u0z/zero-graph
   

   oder Garn verwenden:

   yarn add @u0z/zero-graph
   

3. Überprüfen der Installation
   Erstellen Sie eine einfache TypeScript-Datei (z. B. test.ts) und führen Sie den folgenden Code aus:

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

   Kompilieren und ausführen:

   tsc test.ts
   node test.js
   

   Wenn eine Erfolgsmeldung ausgegeben wird, wurde die Installation korrekt durchgeführt.

Hauptfunktionen

1. knoten und Fluss

Das Herzstück von ZeroGraph sind Node und Flow, wobei Node eine einzelne Aufgabe bearbeitet und Flow mehrere Nodes orchestriert. Schritte:

• Knotenpunkte definieren Erstellen einer Vererbung Node Klasse, die die prep(Daten vorbereiten),exec(Ausführungslogik) und post(Ergebnisse speichern) Methode. Beispiel:

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;
}
}

• Streams erstellen Verbinden Sie den Knoten mit Flow und starten Sie ihn:

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

2. die Stapelverarbeitung

BatchNode ist für die Verarbeitung mehrerer Daten geeignet. Arbeitsschritte:

• Definition von Batch-Knoten ::

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

• Ausführen eines Batch-Streams ::

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

3. asynchrone Operationen (Async-Unterstützung)

AsyncNode unterstützt asynchrone Aufgaben wie z. B. API-Aufrufe. Arbeitsschritte:

• Asynchrone Knoten definieren ::

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

• Ausführen eines asynchronen Stroms ::

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

4. die Zusammenarbeit von Multi-Agenten

ZeroGraph unterstützt Multi-Agenten-Workflows. Operative Schritte:

• Definieren mehrerer Knotenpunkte Node: Erstellen Sie mehrere Node-Klassen, um verschiedene Aufgaben zu erledigen.
• Anschlussknoten : durch next Methode legt die Sprunglogik zwischen den Knoten fest:

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. die Verwendung von Beispielcode

ZeroGraph bietet eine Fülle von Beispielen in der examples/ Katalog. Betriebsverfahren:

• Klon-Lager ::

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

• laufendes Beispiel : Zugang examples/ Verzeichnis, um ein bestimmtes Beispiel auszuführen:

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

• Beispiele sind grundlegende Begrüßungen (hello-world), Suchagenten (agent), Inhaltsgenerierung (workflow), Stapelverarbeitung (batch), asynchrone Operationen (async), Generierung von Sucherweiterungen (rag) und Zusammenarbeit mehrerer Agenten (multi-agent).

caveat

• TypeScript-Konfiguration Sicherstellen, dass das Projekt Folgendes enthält tsconfig.json, empfohlene Einstellungen:

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

• Zugang zu Dokumenten Die vollständige Dokumentation ist zu finden unter docs/ Katalog mit Kernkonzepten, Entwurfsmustern und API-Referenzen.
• Unterstützung der Gemeinschaft : Prüfen Sie GitHub Issues oder reichen Sie einen neuen Issue ein, wenn Sie Probleme haben.

Anwendungsszenario

1. AI Agent Rapid Prototyping
   Das leichtgewichtige Design von ZeroGraph eignet sich für das schnelle Prototyping von KI-Agenten. Entwickler können zum Beispiel einen Suchagenten erstellen, der Web-APIs kombiniert, um Informationen in Echtzeit abzurufen.
2. Automatisierte Arbeitsabläufe
   In Szenarien der Inhaltserstellung oder Datenverarbeitung orchestriert ZeroGraph Multi-Knoten-Workflows, wie z.B. die automatische Erstellung von Artikeln oder die Verarbeitung von Massendaten.
3. Bildung und Forschung
   Studenten und Forscher können TypeScript und die Programmierung von KI-Agenten mit ZeroGraph erlernen, mit Beispielcode, der sich für den Unterricht und zum Experimentieren eignet.

QA

1. Was ist der Unterschied zwischen ZeroGraph und LangChain?
   ZeroGraph besteht aus nur 300 Zeilen Code und konzentriert sich auf die leichtgewichtige Programmierung von KI-Agenten, ohne Abhängigkeiten und mit nativem TypeScript, während LangChain komplexer ist und eine große Menge an Code (405.000 Zeilen) enthält, was es für große Projekte geeignet macht, aber zu Leistungseinbußen führt.
2. Sie brauchen TypeScript-Erfahrung?
   Grundlegende JavaScript-Kenntnisse reichen für den Einstieg aus, und die Typsicherheitsfunktionen von TypeScript werden automatisch von der IDE abgefragt, was die Lernkurve reduziert.
3. Wie kann ich meinen Code debuggen?
   Verwenden Sie eine IDE wie VS Code in Verbindung mit einem TypeScript-Debugging-Tool. ausführen ts-node Führen Sie den Code aus und sehen Sie sich die Konsolenausgabe oder das Protokoll an.
4. Welche komplexen Aufgaben werden unterstützt?
   Unterstützt Multi-Agenten-Zusammenarbeit, RAG (retrieval-enhanced generation) und asynchrone Workflows für Szenarien wie Suche und Inhaltsgenerierung.