Erstellen eines ReAct-Agenten von Grund auf mit nodeJS (Wikipedia-Suche)

Einführung

Wir erstellen einen KI-Agenten, der in der Lage ist, Wikipedia zu durchsuchen und Fragen basierend auf den gefundenen Informationen zu beantworten. Dieser ReAct-Agent (Reason and Act) verwendet die Google Generative AI API, um Anfragen zu verarbeiten und Antworten zu generieren. Unser Agent kann:

1. Durchsuchen Sie Wikipedia nach relevanten Informationen.
2. Bestimmte Abschnitte aus Wikipedia-Seiten extrahieren.
3. Begründen Sie die gesammelten Informationen und formulieren Sie Antworten.

[2] Was ist ein ReAct-Agent?

Ein ReAct-Agent ist ein bestimmter Agententyp, der einem Reflexions-Aktions-Zyklus folgt. Es reflektiert die aktuelle Aufgabe auf der Grundlage der verfügbaren Informationen und Aktionen, die es ausführen kann, und entscheidet dann, welche Aktion ausgeführt werden soll oder ob die Aufgabe abgeschlossen werden soll.

[3] Planung des Agenten

3.1 Erforderliche Werkzeuge

• Node.js
• Axios-Bibliothek für HTTP-Anfragen
• Google Generative AI API (gemini-1.5-flash)
• Wikipedia-API

3.2 Agentenstruktur

Unser ReAct Agent wird drei Hauptzustände haben:

1. GEDENK (Reflexion)
2. AKTION (Ausführung)
3. ANTWORT (Antwort)

[4] Implementierung des Agenten

Lassen Sie uns Schritt für Schritt den ReAct Agent erstellen und dabei jeden Zustand hervorheben.

4.1 Ersteinrichtung

Richten Sie zunächst das Projekt ein und installieren Sie Abhängigkeiten:

mkdir react-agent-project
cd react-agent-project
npm init -y
npm install axios dotenv @google/generative-ai

Erstellen Sie eine .env-Datei im Stammverzeichnis des Projekts:

GOOGLE_AI_API_KEY=your_api_key_here

4.2 Erstellen der Tools.js-Datei

Erstellen Sie Tools.js mit folgendem Inhalt:

const axios = require("axios");

class Tools {
  static async wikipedia(q) {
    try {
      const response = await axios.get("https://en.wikipedia.org/w/api.php", {
        params: {
          action: "query",
          list: "search",
          srsearch: q,
          srwhat: "text",
          format: "json",
          srlimit: 4,
        },
      });

      const results = await Promise.all(
        response.data.query.search.map(async (searchResult) => {
          const sectionResponse = await axios.get(
            "https://en.wikipedia.org/w/api.php",
            {
              params: {
                action: "parse",
                pageid: searchResult.pageid,
                prop: "sections",
                format: "json",
              },
            },
          );

          const sections = Object.values(
            sectionResponse.data.parse.sections,
          ).map((section) => `${section.index}, ${section.line}`);

          return {
            pageTitle: searchResult.title,
            snippet: searchResult.snippet,
            pageId: searchResult.pageid,
            sections: sections,
          };
        }),
      );

      return results
        .map(
          (result) =>
            `Snippet: ${result.snippet}\nPageId: ${result.pageId}\nSections: ${JSON.stringify(result.sections)}`,
        )
        .join("\n\n");
    } catch (error) {
      console.error("Error fetching from Wikipedia:", error);
      return "Error fetching data from Wikipedia";
    }
  }

  static async wikipedia_with_pageId(pageId, sectionId) {
    if (sectionId) {
      const response = await axios.get("https://en.wikipedia.org/w/api.php", {
        params: {
          action: "parse",
          format: "json",
          pageid: parseInt(pageId),
          prop: "wikitext",
          section: parseInt(sectionId),
          disabletoc: 1,
        },
      });
      return Object.values(response.data.parse?.wikitext ?? {})[0]?.substring(
        0,
        25000,
      );
    } else {
      const response = await axios.get("https://en.wikipedia.org/w/api.php", {
        params: {
          action: "query",
          pageids: parseInt(pageId),
          prop: "extracts",
          exintro: true,
          explaintext: true,
          format: "json",
        },
      });
      return Object.values(response.data?.query.pages)[0]?.extract;
    }
  }
}

module.exports = Tools;

4.3 Erstellen der ReactAgent.js-Datei

Erstellen Sie ReactAgent.js mit folgendem Inhalt:

require("dotenv").config();
const { GoogleGenerativeAI } = require("@google/generative-ai");
const Tools = require("./Tools");

const genAI = new GoogleGenerativeAI(process.env.GOOGLE_AI_API_KEY);

class ReActAgent {
  constructor(query, functions) {
    this.query = query;
    this.functions = new Set(functions);
    this.state = "THOUGHT";
    this._history = [];
    this.model = genAI.getGenerativeModel({
      model: "gemini-1.5-flash",
      temperature: 2,
    });
  }

  get history() {
    return this._history;
  }

  pushHistory(value) {
    this._history.push(`\n ${value}`);
  }

  async run() {
    this.pushHistory(`**Task: ${this.query} **`);
    try {
      return await this.step();
    } catch (e) {
      if (e.message.includes("exhausted")) {
        return "Sorry, I'm exhausted, I can't process your request anymore. ><";
      }
      return "Unable to process your request, please try again? ><";
    }
  }

  async step() {
    const colors = {
      reset: "\x1b[0m",
      yellow: "\x1b[33m",
      red: "\x1b[31m",
      cyan: "\x1b[36m",
    };

    console.log("====================================");
    console.log(
      `Next Movement: ${
        this.state === "THOUGHT"
          ? colors.yellow
          : this.state === "ACTION"
            ? colors.red
            : this.state === "ANSWER"
              ? colors.cyan
              : colors.reset
      }${this.state}${colors.reset}`,
    );
    console.log(`Last Movement: ${this.history[this.history.length - 1]}`);
    console.log("====================================");
    switch (this.state) {
      case "THOUGHT":
        await this.thought();
        break;
      case "ACTION":
        await this.action();
        break;
      case "ANSWER":
        await this.answer();
        break;
    }
  }

  async promptModel(prompt) {
    const result = await this.model.generateContent(prompt);
    const response = await result.response;
    return response.text();
  }

  async thought() {
    const availableFunctions = JSON.stringify(Array.from(this.functions));
    const historyContext = this.history.join("\n");
    const prompt = `Your task to FullFill ${this.query}.
Context contains all the reflection you made so far and the ActionResult you collected.
AvailableActions are functions you can call whenever you need more data.

Context: "${historyContext}" <<

AvailableActions: "${availableFunctions}" <<

Task: "${this.query}" <<

Reflect uppon Your Task using Context, ActionResult and AvailableActions to find your next_step.
print your next_step with a Thought or FullFill Your Task `;

    const thought = await this.promptModel(prompt);
    this.pushHistory(`\n **${thought.trim()}**`);
    if (
      thought.toLowerCase().includes("fullfill") ||
      thought.toLowerCase().includes("fulfill")
    ) {
      this.state = "ANSWER";
      return await this.step();
    }
    this.state = "ACTION";
    return await this.step();
  }

  async action() {
    const action = await this.decideAction();
    this.pushHistory(`** Action: ${action} **`);
    const result = await this.executeFunctionCall(action);
    this.pushHistory(`** ActionResult: ${result} **`);
    this.state = "THOUGHT";
    return await this.step();
  }

  async decideAction() {
    const availableFunctions = JSON.stringify(Array.from(this.functions));
    const historyContext = this.history;
    const prompt = `Reflect uppon the Thought, Query and AvailableActions

    ${historyContext[historyContext.length - 2]}

    Thought <<< ${historyContext[historyContext.length - 1]}

    Query: "${this.query}"

    AvailableActions: ${availableFunctions}

    output only the function,parametervalues separated by a comma. For example: "wikipedia,ronaldinho gaucho, 1450"`;

    const decision = await this.promptModel(prompt);
    return `${decision.replace(/`/g, "").trim()}`;
  }

  async executeFunctionCall(functionCall) {
    const [functionName, ...args] = functionCall.split(",");
    const func = Tools[functionName.trim()];
    if (func) {
      return await func.call(null, ...args);
    }
    throw new Error(`Function ${functionName} not found`);
  }

  async answer() {
    const historyContext = this.history;
    const prompt = `Based on the following context, provide a complete, detailed and descriptive formated answer for the Following Task: ${this.query} .

Context:
${historyContext}

Task: "${this.query}"`;

    const finalAnswer = await this.promptModel(prompt);
    this.history.push(`Answer: ${this.finalAnswer}`);
    console.log("WE WILL ANSWER >>>>>>>", finalAnswer);
    return finalAnswer;
  }
}

module.exports = ReActAgent;

4.4 Ausführen des Agenten (index.js)

Erstellen Sie index.js mit folgendem Inhalt:

const ReActAgent = require("./ReactAgent.js");

async function main() {
  const query = "What does England border with?";
  const functions = [
    [
      "wikipedia",
      "params: query",
      "Semantic Search Wikipedia API for snippets, pageIds and sectionIds >> \n ex: Date brazil has been colonized? \n Brazil was colonized at 1500, pageId, sections : []",
    ],
    [
      "wikipedia_with_pageId",
      "params : pageId, sectionId",
      "Search Wikipedia API for data using a pageId and a sectionIndex as params.  \n ex: 1500, 1234 \n Section information about blablalbal",
    ],
  ];

  const agent = new ReActAgent(query, functions);
  try {
    const result = await agent.run();
    console.log("THE AGENT RETURN THE FOLLOWING >>>", result);
  } catch (e) {
    console.log("FAILED TO RUN T.T", e);
  }
}

main().catch(console.error);

[5] So funktioniert der Wikipedia-Teil

Die Interaktion mit Wikipedia erfolgt in zwei Hauptschritten:

1. Erste Suche (Wikipedia-Funktion):

   • Stellt eine Anfrage an die Wikipedia-Such-API.
   • Gibt bis zu 4 relevante Ergebnisse für die Abfrage zurück.
   • Für jedes Ergebnis werden die Abschnitte der Seite abgerufen.

2. Detaillierte Suche (wikipedia_with_pageId-Funktion):

   • Verwendet die Seiten-ID und die Abschnitts-ID, um bestimmte Inhalte abzurufen.
   • Gibt den Text des angeforderten Abschnitts zurück.

Dieser Prozess ermöglicht es dem Agenten, sich zunächst einen Überblick über Themen im Zusammenhang mit der Anfrage zu verschaffen und dann bei Bedarf tiefer in bestimmte Abschnitte einzutauchen.

[6] Beispiel für einen Ausführungsablauf

1. Der Benutzer stellt eine Frage.
2. Der Agent geht in den GEDANKEN-Zustand über und denkt über die Frage nach.
3. Es beschließt, Wikipedia zu durchsuchen und wechselt in den ACTION-Status.
4. Führt die Wikipedia-Funktion aus und erhält Ergebnisse.
5. Kehrt in den GEDANKEN-Zustand zurück, um über die Ergebnisse nachzudenken.
6. Kann sich entscheiden, nach weiteren Details oder einem anderen Ansatz zu suchen.
7. Wiederholt den GEDANKEN- und HANDLUNGS-Zyklus nach Bedarf.
8. Wenn genügend Informationen vorliegen, wechselt es in den ANTWORT-Status.
9. Generiert eine endgültige Antwort basierend auf allen gesammelten Informationen.
10. Betritt eine Endlosschleife, wenn die Wikipedia nicht über die zu sammelnden Daten verfügt. Beheben Sie das Problem mit einem Timer =P

[7] Abschließende Überlegungen

• Der modulare Aufbau ermöglicht das einfache Hinzufügen neuer Tools oder APIs.
• Es ist wichtig, Fehlerbehandlung und Zeit-/Iterationsgrenzen zu implementieren, um Endlosschleifen oder übermäßigen Ressourcenverbrauch zu vermeiden.
• Verwendungstemperatur: 99999 lol

Das obige ist der detaillierte Inhalt vonErstellen eines ReAct-Agenten von Grund auf mit nodeJS (Wikipedia-Suche). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!