Mencipta Ejen AI ReAct dengan Node.js (carian Wikipedia) en

pengenalan

Kami akan mencipta ejen AI yang mampu mencari Wikipedia dan menjawab soalan berdasarkan maklumat yang dikumpul.
Ejen ReAct (Reasoning and Action) ini menggunakan API AI Generatif Google untuk memproses pertanyaan dan menjana respons.

Agen kami akan dapat:

1. Cari maklumat yang berkaitan di Wikipedia.
2. Ekstrak bahagian tertentu daripada halaman Wikipedia.
3. Sebab tentang maklumat yang dikumpul dan rumuskan respons.

[2] Apakah itu Ejen ReAct?

Ejen ReAct ialah jenis ejen tertentu yang mengikuti kitaran Refleksi-Tindakan. Ia mencerminkan tugas semasa, berdasarkan maklumat yang tersedia dan tindakan yang boleh diambilnya, dan kemudian memutuskan tindakan yang perlu diambil atau sama ada untuk menyelesaikan tugas itu.

[3] Merancang Ejen

3.1 Alat yang Diperlukan

• Node.js
• Pustaka Axios untuk permintaan HTTP
• API AI Generatif Google (gemini-1.5-flash)
• API Wikipedia

3.2 Struktur Ejen

Ejen ReAct kami akan mempunyai tiga keadaan utama:

1. FIKIR (Refleksi)
2. TINDAKAN (Pelaksanaan)
3. JAWAPAN (Balas)

3.3 Keadaan Pemikiran

Keadaan berfikir ialah saat di mana ReactAgent akan memikirkan maklumat yang dikumpul dan memutuskan langkah seterusnya yang sepatutnya.

async thought() {
    // ...
}

3.4 Keadaan Tindakan (ACTION)

Dalam keadaan tindakan, ejen melaksanakan salah satu fungsi yang tersedia berdasarkan Pemikiran sebelumnya.
Ambil perhatian bahawa terdapat tindakan (pelaksanaan) dan keputusan (tindakan yang mana).

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] Pelaksana Ejen

Mari bina Ejen ReAct langkah demi langkah, menyerlahkan setiap keadaan.

4.1 Konfigurasi Awal

Mula-mula, konfigurasikan projek dan pasang kebergantungan:

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

Buat fail .env dalam akar projek:

GOOGLE_AI_API_KEY=sua_chave_api_aqui

Kunci API PERCUMA di sini

4.2 Penyataan Peranan

Fail ini ialah fail JavaScript yang akan digunakan oleh Node.js untuk melakukan panggilan API ke Wikipedia.
Kami menerangkan kandungan fail ini dalam FunctionDescription.

Buat Tools.js dengan kandungan berikut:

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 Mencipta Fail ReactAgent.js

Buat ReactAgent.js dengan kandungan berikut:

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 Menjalankan Ejen dan Menjelaskan Alat Tersedia (index.js)

Buat index.js dengan kandungan berikut:

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

Penerangan Peranan

Apabila cuba menambah alat atau fungsi baharu, pastikan anda menerangkannya dengan baik.
Dalam contoh kami, ini telah dilakukan dan ditambahkan pada kelas ReActAgent kami apabila memanggil Instance baharu.

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] Bagaimana Bahagian Wikipedia Berfungsi

Interaksi dengan Wikipedia dilakukan dalam dua langkah utama:

1. Carian awal (fungsi wikipedia):

   • Membuat permintaan kepada API carian Wikipedia.
   • Mengembalikan sehingga 4 hasil carian yang berkaitan dengan pertanyaan.
   • Untuk setiap hasil carian, cari bahagian halaman.

2. Carian terperinci (wikipedia_with_pageId function):

   • Menggunakan ID halaman dan ID bahagian untuk mencari kandungan tertentu.
   • Mengembalikan teks bahagian yang diminta.

Proses ini membolehkan ejen mendapat gambaran keseluruhan topik yang berkaitan dengan pertanyaan dahulu dan kemudian menelusuri bahagian tertentu mengikut keperluan.

[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.

Atas ialah kandungan terperinci Mencipta Ejen AI ReAct dengan Node.js (carian Wikipedia) en. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!