Création d'un agent ReAct AI avec Node.js (recherche Wikipédia) fr

Introduction

Nous allons créer un agent IA capable de rechercher Wikipédia et de répondre aux questions en fonction des informations collectées.
Cet agent ReAct (Reasoning and Action) utilise l'API Google Generative AI pour traiter les requêtes et générer des réponses.

Notre agent pourra :

1. Recherchez des informations pertinentes sur Wikipédia.
2. Extraire des sections spécifiques des pages Wikipédia.
3. Raisonner sur les informations collectées et formuler des réponses.

[2] Qu'est-ce qu'un agent ReAct ?

Un Agent ReAct est un type spécifique d'agent qui suit un cycle Réflexion-Action. Il réfléchit à la tâche en cours, en fonction des informations disponibles et des actions qu'il peut entreprendre, puis décide quelle action entreprendre ou s'il doit terminer la tâche.

[3] Planification de l'agent

3.1 Outils requis

• Node.js
• Bibliothèque Axios pour les requêtes HTTP
• API Google IA générative (gemini-1.5-flash)
• API Wikipédia

3.2 Structure des agents

Notre agent ReAct aura trois états principaux :

1. PENSÉE (Réflexion)
2. ACTION (Exécution)
3. RÉPONSE (Répondre)

3.3 État de pensée

L'état de réflexion est le moment où ReactAgent réfléchira aux informations collectées et décidera quelle devrait être la prochaine étape.

async thought() {
    // ...
}

3.4 État d'action (ACTION)

Dans l'état d'action, l'agent exécute l'une des fonctions disponibles en fonction de la pensée précédente.
Notez qu'il y a l'action (exécution) et la décision (quelle action).

async action() {
    // chama a decisão
    // executa a ação e retorna um ActionResult
}

async decideAction() {
    // Chama o LLM com base no Pensamento (reflexão) para formatar e adequar a chamada de função.
    // Procure por um modo de função-ferramenta na [documentação da API do Google](https://ai.google.dev/gemini-api/docs/function-calling)
}

[4] Implémentation de l'agent

Construisons l'agent ReAct étape par étape, en mettant en évidence chaque état.

4.1 Configuration initiale

Tout d'abord, configurez le projet et installez les dépendances :

mkdir projeto-agente-react
cd projeto-agente-react
npm init -y
npm install axios dotenv @google/generative-ai

Créez un fichier .env à la racine du projet :

GOOGLE_AI_API_KEY=sua_chave_api_aqui

Clé API GRATUITE ici

4.2 Énoncé de rôle

Ce fichier est le fichier JavaScript que Node.js utilisera pour effectuer un appel API vers Wikipédia.
Nous décrivons le contenu de ce fichier dans FunctionDescription.

Créez Tools.js avec le contenu suivant :

const axios = require("axios");

class Tools {
  static async wikipedia(q) {
    try {
      const response = await axios.get("https://pt.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://pt.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://pt.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://pt.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 Création du fichier ReactAgent.js

Créez ReactAgent.js avec le contenu suivant :

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: 1.8,
    });
  }

  async run() {
    this.pushHistory(`**Tarefa: ${this.query} **`);
    try {
      return await this.step();
    } catch (e) {
      console.error("Erro durante a execução:", e);
      return "Desculpe, não consegui processar sua solicitação.";
    }
  }

  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":
        return await this.thought();
        break;
      case "ACTION":
        return await this.action();
        break;
      case "ANSWER":
        return await this.answer();
    }
  }

  async thought() {
    const funcoesDisponiveis = JSON.stringify(Array.from(this.functions));
    const contextoHistorico = this.history.join("\n");
    const prompt = `Sua Tarefa é ${this.consulta}
O Contexto posui todas as reflexões que você fez até agora e os ResultadoAção que coletou.
AçõesDisponíveis são funções que você pode chamar sempre que precisar de mais dados.

Contexto: "${contextoHistorico}" <<

AçõesDisponíveis: "${funcoesDisponiveis}" <<

Tarefa: "${this.consulta}" <<

Reflita sobre Sua Tarefa usando o Contexto, ResultadoAção e AçõesDisponíveis para encontrar seu próximo_passo.
Imprima seu próximo_passo com um Pensamento ou Finalize Cumprindo Sua Tarefa caso tenha as informações disponíveis`;

    const thought = await this.promptModel(prompt);
    this.pushHistory(`\n **${thought.trim()}**`);

    if (
      thought.toLowerCase().includes("cumprida") ||
      thought.toLowerCase().includes("cumpra") ||
      thought.toLowerCase().includes("cumprindo") ||
      thought.toLowerCase().includes("finalizar") ||
      thought.toLowerCase().includes("finalizando") ||
      thought.toLowerCase().includes("finalize") ||
      thought.toLowerCase().includes("concluída")
    ) {
      this.state = "ANSWER";
    } else {
      this.state = "ACTION";
    }
    return this.step();
  }

  async action() {
    const action = await this.decideAction();
    this.pushHistory(`** Ação: ${action} **`);
    const result = await this.executeFunctionCall(action);
    this.pushHistory(`** ResultadoAção: ${result} **`);
    this.state = "THOUGHT";
    return this.step();
  }

  async decideAction() {
    const availableFunctions = JSON.stringify(Array.from(this.functions));
    const historyContext = this.history;
    const prompt = `Reflita sobre o Pensamento, Consulta e Ações Disponíveis

    ${historyContext[historyContext.length - 2]}

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

    Consulta: "${this.query}"

    Ações Disponíveis: ${availableFunctions}

    Retorne apenas a função,parâmetros separados por vírgula. Exemplo: "wikipedia,ronaldinho gaucho,1450"`;

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

  async answer() {
    const historyContext = this.history.join("\n");
    const prompt = `Com base no seguinte contexto, forneça uma resposta completa e detalhada para a tarefa: ${this.query}.

    Contexto:
    ${historyContext}

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

    const finalAnswer = await this.promptModel(prompt);
    return finalAnswer;
  }

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

  async executeFunctionCall(functionCall) {
    const [functionName, ...args] = functionCall.split(",");
    const func = Tools[functionName.trim()];
    if (func) {
      return await func.call(null, ...args);
    }
    throw new Error(`Função ${functionName} não encontrada`);
  }

  pushHistory(value) {
    this._history.push(value);
  }

  get history() {
    return this._history;
  }
}

module.exports = ReactAgent;

4.4 Exécution de l'agent et explication des outils disponibles (index.js)

Créez index.js avec le contenu suivant :

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

async function main() {
  const query = "Que clubes ronaldinho gaúcho jogou para?";
  // const query = "Quais os bairros de Joinville?";
  // const query = "Qual a capital da frança?";

  const functions = [
    [
      "wikipedia",
      "params: query",
      "Busca semântica na Wikipedia API por pageId e sectionIds >> \n ex: Pontos turísticos de são paulo \n São Paulo é uma cidade com muitos pontos turísticos, pageId, sections : []",
    ],
    [
      "wikipedia_with_pageId",
      "params: pageId, sectionId",
      "Busca na Wikipedia API usando pageId e sectionIndex como parametros. \n ex: 1500,1234 \n Informações sobre a seção blablalbal",
    ],
  ];

  const agent = new ReactAgent(query, functions);
  const result = await agent.run();
  console.log("Resultado do Agente:", result);
}

main().catch(console.error);

Description du rôle

Lorsque vous essayez d'ajouter un nouvel outil ou une nouvelle fonction, assurez-vous de bien le décrire.
Dans notre exemple, cela est déjà fait et ajouté à notre classe ReActAgent lors de l'appel d'une nouvelle instance.

const functions = [
    [
        "google", // nomeDaFuncao
        "params: query", // NomeDoParâmetroLocal
        "Pesquisa semântica na API da Wikipedia por snippets, pageIds e sectionIds >> \n ex: Quando o Brasil foi colonizado? \n O Brasil foi colonizado em 1500, pageId, sections : []", // breve explicação e exemplo (isso será encaminhado para o LLM)
    ]
];

[5] Comment fonctionne la partie Wikipédia

L'interaction avec Wikipédia se fait en deux étapes principales :

1. Recherche initiale (fonction wikipedia) :

   • Fait une requête à l'API de recherche Wikipédia.
   • Renvoie jusqu'à 4 résultats pertinents pour la requête.
   • Pour chaque résultat, recherchez les sections de la page.

2. Recherche détaillée (fonction wikipedia_with_pageId) :

   • Utilise l'ID de page et l'ID de section pour rechercher un contenu spécifique.
   • Renvoie le texte de la section demandée.

Ce processus permet à l'agent d'obtenir d'abord un aperçu des sujets liés à la requête, puis d'explorer des sections spécifiques si nécessaire.

[6] Contoh Aliran Pelaksanaan

1. Pengguna bertanya soalan.
2. Ejen memasuki keadaan FIKIR dan memikirkan soalan.
3. Dia memutuskan untuk mencari Wikipedia dan memasuki keadaan ACTION.
4. Menjalankan fungsi wikipedia dan mendapat hasil.
5. Kembali ke keadaan FIKIR untuk merenung keputusan.
6. Anda boleh memutuskan untuk mencari butiran lanjut atau pendekatan yang berbeza.
7. Ulang kitaran PEMIKIRAN dan TINDAKAN mengikut keperluan.
8. Apabila ia mempunyai maklumat yang mencukupi, ia memasuki keadaan JAWAPAN.
9. Menjana respons akhir berdasarkan semua maklumat yang dikumpul.
10. Masukkan gelung tak terhingga apabila Wikipedia tidak mempunyai data untuk dikumpulkan. Betulkan ini dengan pemasa =P

[7] Pertimbangan Akhir

• Struktur modular membolehkan penambahan alat atau API baharu dengan mudah.
• Adalah penting untuk melaksanakan pengendalian ralat dan had masa/lelaran untuk mengelakkan gelung tidak terhingga atau penggunaan sumber yang berlebihan.
• Contoh ini menggunakan suhu 2. Semakin rendah suhu, semakin kurang kreatif ejen semasa lelaran. Eksperimen untuk memahami pengaruh suhu pada LLM.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!