DEV Community: Allan Felipe Murara

Causality — Transformers Theory

Allan Felipe Murara — Sat, 29 Aug 2026 01:18:38 +0000

This is not a simple assumption, here lies notes that helps us think on transformers, and observe its phennomena, from a inside-out view of attention (Human and LLMS Colliding).

A funny mind-game

Let me invite you to think…

You must choose 2 languages, one that you are fluent, and one that you have almost no idea, or ideally knows not how to spell ride a bicycle… Take your time, choose the language.

Count to 10, simulating 10 seconds.

Game is on : Think on word :

ROAD. Count to 3.

Given the choosen secondary language, search around for its translation. What is the translation for ROAD?

Estrada.

If you pick portuguese, don’t worry! Just accept, You saw a car driving towards “Estrada”.

And a tought emmerged in your mind, You saw a car driving in a Estrada and it was so real…

I can’t advocate or prove that this effect happens every single time, but hence, I invite you instead to reflect :
Is this what we call Attention?
Welcome, I hope you enjoy as much as I enjoy the challenge of the human mind.

Now the notes about causality I promised :

`The space time considered in acquiring context, When one try to express "I want to go to the supermarket."

Assumin Person1 talking to Person2: Can be asking info, talking about buying something, saw something ....

In a space-time of summarization, supermarket can only be causually related to "Buying, selling, acquiring,", "products", "viewing"... gradually break into each space ( grammatical, situational or any ) at a time ((figure of speech, person) Travelling, shopping ) "I", "Where". "

I" can be observed in the linear time-space of the person 2, even if the shotcaller is person1. Cause there is a causal collision of "personas_latent_time_space". Where persona 2 Cause I (P2) might need to give information to You (P1).

But You(P1) can be willing get infr This all can be summed up with a paralele space-time, as "Person1" is talking to "Person2", in a sense that "Where, "you" and third level cogna ( empathetic level etc ) space, such as ocuppying a place, directing to a place, getting a direction to a place, Throwing something at a place are more related to this second "Space-time".

Trying to explain the chain : When one thinks of supermarket, there is just some impulses that can be related to that, which will be gradually evaluated depending on the time-space ( variant ) then linear. Linear in a sense of subjugating all possibilitles into "context-space-times". Where I Supermarket Buy Food If the time-space is linear "Person1-Speaker-English" If the time-space is linear "Person2-Understands-English", then I Supermarket Directiong Give. Then the Time-space variant of the cogna ( P1+P2+Info+....) can be more related to Person1_linear[0]+Person2_linear[0] or Person1_linear[1]+Person2_linear[1] Which is essentially casuality of infor The theory I like to think about casuality is how being able to sum up the variable time-space of a conversation can implictly be converted into a line
`

Creating Multi Agents with NodeJS ( Talk itself into a League of legends Draft with NodeJS )

Allan Felipe Murara — Fri, 27 Sep 2024 05:13:29 +0000

Introduction

In this tutorial, we'll create an AI Multi Agent environment capable of simulating a League of Legends draft pick process.

What is a ReAct Agent?

A ReAct Agent is a type of AI agent that follows a Reflection-Action cycle. It reflects on the current task, based on available information and actions it can perform, and then decides which action to take or whether to conclude the task.

Agent Structure

Our ReActAgent will have three main states:

THOUGHT (Reflection)
ACTION (Execution)
ANSWER (Response)

Let's Convert this Agent into MultiAgents and the DraftModerator and let the Talk start!!

[1] Initial Setup

First, set up the project and install dependencies:

mkdir lol-draft-simulator
cd lol-draft-simulator
npm init -y
npm install irc @google/generative-ai dotenv

1. Create a `.env` file at the project's root:

GOOGLE_AI_API_KEY=your_api_key_here

FREE ApiKey here

2. ReActAgent.js

The ReAct agent is the class used in each of the players.
Given the ability of react into some situation, they play a fundamental role in building the outcome.

Create ReActAgent.js with the following content:

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

class ReActAgent {
  constructor(query, functions, championPool, ircClient, channel) {
    this.query = query;
    this.functions = new Set(functions);
    this.championPool = championPool;
    this.state = "THOUGHT";
    this._history = [];
    this.model = new GoogleGenerativeAI(process.env.GOOGLE_AI_API_KEY).getGenerativeModel({
      model: "gemini-pro",
      temperature: 0.9,
    });
    this.ircClient = ircClient;
    this.channel = channel;
  }

  get history() {
    return this._history;
  }

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

  async run(ownComp, enemyComp) {
    this.pushHistory(`**Task: ${this.query} **`);
    this.pushHistory(`Own team composition: ${JSON.stringify(ownComp)}`);
    this.pushHistory(`Enemy team composition: ${JSON.stringify(enemyComp)}`);
    try {
      return await this.step(ownComp, enemyComp);
    } catch (e) {
      console.error("Error in ReActAgent:", e);
      return "Unable to process the draft pick. Please try again.";
    }
  }

  async step(ownComp, enemyComp) {
    console.log(`Current state: ${this.state}`);
    switch (this.state) {
      case "THOUGHT":
        return await this.thought(ownComp, enemyComp);
      case "ACTION":
        return await this.action(ownComp, enemyComp);
      case "ANSWER":
        return await this.answer();
    }
  }

  async promptModel(prompt) {
    try {
      const result = await this.model.generateContent(prompt);
      const response = await result.response;
      return response.text();
    } catch (error) {
      console.error("Error in promptModel:", error);
      return "Error occurred while generating content.";
    }
  }

  async thought(ownComp, enemyComp) {
    const availableFunctions = JSON.stringify(Array.from(this.functions));
    const historyContext = this.history.join("\n");
    const prompt = `You are a League of Legends player in a draft phase. ${this.query}
Whenever there is no opponent composition, it means you are the first.
Your champion pool: ${this.championPool.join(", ")}
Your team composition: ${JSON.stringify(ownComp)}
Enemy team composition: ${JSON.stringify(enemyComp)}
Available actions: ${availableFunctions}
This is a competitive draft so champions can't be repeated.

Based on the current compositions and your champion pool, think about the best pick for your team.
If you are the first, think carefully based on your championPool what to pick in a direction to enabling your team comp.
Then, decide whether to analyze the composition further or make a champion pick.

Context: "${historyContext}"

Respond with your decision in form of a thought and whether you want to "Analyze" or "Pick".`;

    const thought = await this.promptModel(prompt);
    this.pushHistory(`\n **${thought.trim()}**`);
    if (thought.toLowerCase().includes("pick")) {
      this.state = "ANSWER";
    } else {
      this.state = "ACTION";
    }
    return await this.step(ownComp, enemyComp);
  }

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

  async analyzeComposition(ownComp, enemyComp) {
    const prompt = `Analyze the following team compositions:
Own team: ${JSON.stringify(ownComp)}
Enemy team: ${JSON.stringify(enemyComp)}

Consider team synergies, counter picks, and overall strategy. Suggest potential champions from your pool that would fit well.
Your champion pool: ${this.championPool.join(", ")}

Provide a brief analysis and champion suggestions.`;

    return await this.promptModel(prompt);
  }

  async answer() {
    const historyContext = this.history.join("\n");
    const prompt = `Based on the following context and analysis, choose a champion for the draft.
Your champion pool: ${this.championPool.join(", ")}

Context: ${historyContext}

reflect(>>>FeedForward<( FlushBackL{< from the Context >>  briefly explain into  _justifiedVerify
Respond with: "I pick [ChampionName]" where [ChampionName] is the champion you've decided and the ups and downs _justifiedVerify
`;

    const finalAnswer = await this.promptModel(prompt);
    this.pushHistory(`Answer: ${finalAnswer}`);
    return finalAnswer;
  }

  say(message) {
    this.ircClient.say(this.channel, message);
  }
}

module.exports = ReActAgent;

3. players.js

Players is the file that hold the information about each player pool, tier MMR, and role.

Create players.js to store player data:

const teamBlue = [
  {
    name: "BlueTop",
    rank: "Diamond III",
    role: "Top",
    championPool: [
      "Aatrox", "Camille", "Darius", "Fiora", "Garen", "Gnar", "Irelia", "Jax",
      "Jayce", "Kennen", "Malphite", "Maokai", "Mordekaiser", "Nasus", "Ornn",
      "Poppy", "Renekton", "Riven", "Sett", "Shen", "Sion", "Teemo", "Urgot",
      "Vladimir", "Volibear",
    ],
  },
  {
    name: "BlueJungle",
    rank: "Platinum I",
    role: "Jungle",
    championPool: [
      "Amumu", "Elise", "Evelynn", "Fiddlesticks", "Gragas", "Graves", "Hecarim",
      "Ivern", "Jarvan IV", "Karthus", "Kayn", "Kha'Zix", "Kindred", "Lee Sin",
      "Master Yi", "Nidalee", "Nunu & Willump", "Olaf", "Rammus", "Rek'Sai",
      "Rengar", "Sejuani", "Shaco", "Trundle", "Udyr", "Vi", "Warwick", "Xin Zhao", "Zac",
    ],
  },
  {
    name: "BlueMid",
    rank: "Diamond II",
    role: "Mid",
    championPool: [
      "Ahri", "Akali", "Anivia", "Annie", "Aurelion Sol", "Azir", "Cassiopeia",
      "Corki", "Diana", "Ekko", "Fizz", "Galio", "Kassadin", "Katarina", "LeBlanc",
      "Lissandra", "Lux", "Malzahar", "Neeko", "Orianna", "Qiyana", "Ryze", "Sylas",
      "Syndra", "Talon", "Twisted Fate", "Veigar", "Viktor", "Yasuo", "Zed", "Ziggs", "Zoe",
    ],
  },
  {
    name: "BlueADC",
    rank: "Diamond III",
    role: "ADC",
    championPool: [
      "Aphelios", "Ashe", "Caitlyn", "Draven", "Ezreal", "Jhin", "Jinx", "Kai'Sa",
      "Kalista", "Kog'Maw", "Lucian", "Miss Fortune", "Senna", "Sivir", "Tristana",
      "Twitch", "Varus", "Vayne", "Xayah",
    ],
  },
  {
    name: "BlueSupport",
    rank: "Platinum II",
    role: "Support",
    championPool: [
      "Alistar", "Bard", "Blitzcrank", "Brand", "Braum", "Janna", "Karma", "Leona",
      "Lulu", "Morgana", "Nami", "Nautilus", "Pyke", "Rakan", "Senna", "Sona",
      "Soraka", "Swain", "Tahm Kench", "Taric", "Thresh", "Vel'Koz", "Xerath",
      "Yuumi", "Zilean", "Zyra",
    ],
  },
];

const teamRed = [
  {
    name: "RedTop",
    rank: "Diamond II",
    role: "Top",
    championPool: [
      "Aatrox", "Camille", "Cho'Gath", "Darius", "Dr. Mundo", "Fiora", "Gangplank",
      "Garen", "Gnar", "Illaoi", "Irelia", "Jax", "Jayce", "Kayle", "Kennen", "Kled",
      "Malphite", "Maokai", "Mordekaiser", "Nasus", "Ornn", "Pantheon", "Poppy",
      "Quinn", "Renekton", "Riven", "Rumble", "Ryze", "Sett", "Shen", "Singed",
      "Sion", "Teemo", "Tryndamere", "Urgot", "Vladimir", "Volibear", "Wukong", "Yorick",
    ],
  },
  {
    name: "RedJungle",
    rank: "Diamond I",
    role: "Jungle",
    championPool: [
      "Amumu", "Elise", "Evelynn", "Fiddlesticks", "Gragas", "Graves", "Hecarim",
      "Ivern", "Jarvan IV", "Karthus", "Kayn", "Kha'Zix", "Kindred", "Lee Sin",
      "Master Yi", "Nidalee", "Nocturne", "Nunu & Willump", "Olaf", "Rammus",
      "Rek'Sai", "Rengar", "Sejuani", "Shaco", "Skarner", "Taliyah", "Trundle",
      "Udyr", "Vi", "Warwick", "Xin Zhao", "Zac",
    ],
  },
  {
    name: "RedMid",
    rank: "Master",
    role: "Mid",
    championPool: [
      "Ahri", "Akali", "Anivia", "Annie", "Aurelion Sol", "Azir", "Cassiopeia",
      "Corki", "Diana", "Ekko", "Fizz", "Galio", "Irelia", "Kassadin", "Katarina",
      "LeBlanc", "Lissandra", "Lux", "Malzahar", "Neeko", "Orianna", "Pantheon",
      "Qiyana", "Rumble", "Ryze", "Sylas", "Syndra", "Talon", "Twisted Fate",
      "Veigar", "Viktor", "Xerath", "Yasuo", "Zed", "Ziggs", "Zoe",
    ],
  },
  {
    name: "RedADC",
    rank: "Diamond II",
    role: "ADC",
    championPool: [
      "Aphelios", "Ashe", "Caitlyn", "Draven", "Ezreal", "Jhin", "Jinx", "Kai'Sa",
      "Kalista", "Kog'Maw", "Lucian", "Miss Fortune", "Senna", "Sivir", "Tristana",
      "Twitch", "Varus", "Vayne", "Xayah",
    ],
  },
  {
    name: "RedSupport",
    rank: "Diamond III",
    role: "Support",
    championPool: [
      "Alistar", "Bard", "Blitzcrank", "Brand", "Braum", "Janna", "Karma", "Leona",
      "Lulu", "Morgana", "Nami", "Nautilus", "Pyke", "Rakan", "Senna", "Sona",
      "Soraka", "Swain", "Tahm Kench", "Taric", "Thresh", "Vel'Koz", "Xerath",
      "Yuumi", "Zilean", "Zyra",
    ],
  },
];

module.exports = { teamBlue, teamRed };

4. DraftSimulator.js

DraftSimulator can be seen as the orchestrator of our agents.
It will store a memory and propagate of each decision and announce state changes.

Create DraftSimulator.js to manage the draft simulation:

const irc = require("irc");
const ReActAgent = require("./ReActAgent");
const { teamBlue, teamRed } = require("./players");

class DraftSimulator {
  constructor() {
    console.log("Initializing Draft Simulator...");
    this.channel = "#leagueoflegends-draft";
    this.blueTeam = this.createTeamAgents(teamBlue, "Blue");
    this.redTeam = this.createTeamAgents(teamRed, "Red");
    this.allPlayers = [...this.blueTeam, ...this.redTeam];
    this.draftOrder = this.generateDraftOrder();
    this.currentPickIndex = 0;
    this.blueComp = { Top: null, Jungle: null, Mid: null, ADC: null, Support: null };
    this.redComp = { Top: null, Jungle: null, Mid: null, ADC: null, Support: null };
    this.draftHistory = [];

    console.log("Setting up IRC client...");
    this.moderatorClient = new irc.Client("irc.libera.chat", "DraftModerator", {
      channels: [this.channel],
      port: 6667,
      autoRejoin: true,
      retryCount: 3,
      debug: false,
    });

    this.setupIRCListeners();
    console.log("Draft Simulator initialized.");
  }

  createTeamAgents(teamData, teamColor) {
    console.log(`Creating ${teamColor} team agents...`);
    return teamData.map((player) => {
      const query = `As ${player.name}, a ${player.rank} ${player.role} player for team ${teamColor}, choose a champion for the current draft.`;
      const functions = [
        ["analyzeComposition", "params: ownComp, enemyComp", "Analyze the current team compositions"],
      ];
      const ircClient = new irc.Client("irc.libera.chat", player.name, {
        channels: [this.channel],
        port: 6667,
        autoRejoin: true,
        retryCount: 3,
        debug: false,
      });
      console.log(`Created agent for ${player.name} (${player.role})`);
      return {
        role: player.role,
        agent: new ReActAgent(query, functions, player.championPool, ircClient, this.channel),
      };
    });
  }

  generateDraftOrder() {
    console.log("Generating draft order...");
    const order = [];
    const blueRoles = ["Top", "Jungle", "Mid", "ADC", "Support"];
    const redRoles = ["Top", "Jungle", "Mid", "ADC", "Support"];

    const pickForTeam = (team, count) => {
      const roles = team === "Blue" ? blueRoles : redRoles;
      for (let i = 0; i < count; i++) {
        if (roles.length > 0) {
          const role = this.getRandomRole(roles);
          order.push({ team, role });
        }
      }
    };

    pickForTeam("Blue", 1);
    pickForTeam("Red", 2);
    pickForTeam("Blue", 2);
    pickForTeam("Red", 2);
    pickForTeam("Blue", 2);
    pickForTeam("Red", 1);

    console.log("Draft order generated:", order);
    return order;
  }

  getRandomRole(roles) {
    const index = Math.floor(Math.random() * roles.length);
    const role = roles[index];
    roles.splice(index, 1);
    return role;
  }

  setupIRCListeners() {
    console.log("Setting up IRC listeners...");
    this.moderatorClient.addListener("error", this.handleIrcError.bind(this));
    this.moderatorClient.addListener("registered", this.handleRegistered.bind(this));
    this.moderatorClient.addListener("join", this.handleJoin.bind(this));
    this.moderatorClient.addListener("message" + this.channel, this.handleMessage.bind(this));
  }

  handleIrcError(message) {
    console.error("IRC Error:", message);
  }

  handleRegistered(message) {
    console.log("Registered with IRC server:", message);
  }

  handleJoin(channel, nick, message) {
    console.log(`Joined ${channel} as ${nick}`);
    if (channel === this.channel && nick === this.moderatorClient.nick) {
      console.log("Moderator joined the correct channel, starting draft...");
      setTimeout(() => this.startDraft(), 1000);
    }
  }

  handleMessage(from, message) {
    console.log(`Message received in ${this.channel}: ${from} => ${message}`);
  }

  async startDraft() {
    console.log("Starting draft...");
    this.moderatorClient.say(this.channel, "Draft is starting!");
    setTimeout(() => this.nextPick(), 1000);
  }

  async nextPick() {
    console.log(`Processing pick ${this.currentPickIndex + 1} of ${this.draftOrder.length}`);
    if (this.currentPickIndex >= this.draftOrder.length) {
      this.endDraft();
      return;
    }

    const currentPick = this.draftOrder[this.currentPickIndex];
    const currentTeam = currentPick.team;
    const currentRole = currentPick.role;
    const teamPlayers = currentTeam === "Blue" ? this.blueTeam : this.redTeam;

    console.log(`Current pick: ${currentTeam} team, ${currentRole} role`);
    this.announceDraftState();

    const currentPlayer = teamPlayers.find((p) => p.role === currentRole);

    if (!currentPlayer) {
      console.error(`No player found for role ${currentRole} in ${currentTeam} team`);
      this.moderatorClient.say(this.channel, `Error: No player found for ${currentRole} in ${currentTeam} team. Skipping this pick.`);
      this.currentPickIndex++;
      setTimeout(() => this.nextPick(), 2000);
      return;
    }

    const ownComp = currentTeam === "Blue" ? this.blueComp : this.redComp;
    const enemyComp = currentTeam === "Blue" ? this.redComp : this.blueComp;

    try {
      console.log(`Requesting pick from ${currentPlayer.agent.query.split(",")[0]}...`);
      const result = await currentPlayer.agent.run(ownComp, enemyComp);
      console.log(`Received result from agent: ${result}`);
      const champion = this.extractChampionFromResult(result);

      if (champion === "Unknown Champion") {
        throw new Error("Failed to extract a valid champion from the result");
      }

      console.log(`Extracted champion: ${champion}`);
      this.processPick(currentTeam, currentRole, champion);
      currentPlayer.agent.say(`I pick ${champion} for ${currentRole}. Justified with: ${result}`);

      this.moderatorClient.say(this.channel, `${currentPlayer.agent.query.split(",")[0]} has picked ${champion} for ${currentRole}.`);

      this.currentPickIndex++;
      setTimeout(() => this.nextPick(), 7000);
    } catch (error) {
      console.error("Error during pick:", error);
      this.moderatorClient.say(this.channel, `An error occurred during the pick. ${currentPlayer.agent.query.split(",")[0]} will be assigned a random champion from their pool.`);
      const randomChampion = this.getRandomChampion(currentPlayer.agent.championPool);
      console.log(`Assigning random champion: ${randomChampion}`);
      this.processPick(currentTeam, currentRole, randomChampion);
      this.moderatorClient.say(this.channel, `${currentPlayer.agent.query.split(",")[0]} has been assigned ${randomChampion} for ${currentRole}.`);
      this.currentPickIndex++;
      setTimeout(() => this.nextPick(), 7000);
    }
  }

  extractChampionFromResult(result) {
    console.log("Extracting champion from result...");
    let match = result.match(/I pick (\w+)/i);
    if (match) return match[1];

    match = result.match(/\*\*(\w+)\*\*/);
    if (match) return match[1];

    const words = result.split(/\s+/);
    for (const word of words) {
      const champion = word.replace(/[^a-zA-Z']/g, "");
      if (this.isValidChampion(champion)) {
        return champion;
      }
    }

    console.log("Unable to extract champion from result.");
    return "Unknown Champion";
  }

  isValidChampion(champion) {
    const allChampions = new Set([
      ...teamBlue.flatMap((player) => player.championPool),
      ...teamRed.flatMap((player) => player.championPool),
    ]);
    return allChampions.has(champion);
  }

  getRandomChampion(championPool) {
    return championPool[Math.floor(Math.random() * championPool.length)];
  }

  announceDraftState() {
    console.log("Announcing current draft state...");
    const blueTeamComp = Object.entries(this.blueComp)
      .map(([role, champion]) => `${role}: ${champion || "Not picked"}`)
      .join(", ");
    const redTeamComp = Object.entries(this.redComp)
      .map(([role, champion]) => `${role}: ${champion || "Not picked"}`)
      .join(", ");

    const currentPick = this.draftOrder[this.currentPickIndex];

    this.moderatorClient.say(
      this.channel,
      `Current Draft State:
      Blue Team: ${blueTeamComp}
      Red Team: ${redTeamComp}
      It's ${currentPick.team} team's turn to pick for ${currentPick.role}.`
    );
  }

  processPick(team, role, champion) {
    console.log(`Processing pick: ${team} ${role} - ${champion}`);
    if (team === "Blue") {
      this.blueComp[role] = champion;
    } else {
      this.redComp[role] = champion;
    }
    this.draftHistory.push(`${team} ${role}: ${champion}`);
  }

  endDraft() {
    console.log("Draft completed!");
    console.log("Blue Team Composition:", this.blueComp);
    console.log("Red Team Composition:", this.redComp);
    this.moderatorClient.say(this.channel, "Draft completed! Final compositions:");
    setTimeout(() => {
      this.moderatorClient.say(this.channel, `Blue Team: ${JSON.stringify(this.blueComp)}`);
    }, 1000);
    setTimeout(() => {
      this.moderatorClient.say(this.channel, `Red Team: ${JSON.stringify(this.redComp)}`);
    }, 2000);

    setTimeout(() => {
      console.log("Disconnecting all clients...");
      this.allPlayers.forEach((player) => player.agent.ircClient.disconnect());
      this.moderatorClient.disconnect("Draft completed", () => {
        console.log("Disconnected from IRC");
        process.exit(0);
      });
    }, 5000);
  }
}

module.exports = DraftSimulator;

5. index.js:

Create index.js in the root project

require("dotenv").config();
const DraftSimulator = require("./DraftSimulator");

async function main() {
  try {
    const simulator = new DraftSimulator();
    // The draft will start automatically when connected to IRC
  } catch (error) {
    console.error("Error in main:", error);
  }
}

main().catch(console.error);

Running the Simulation

To run the simulation, execute:

node index.js

This will start the draft simulation, and you'll see the progress in the console and in the specified IRC channel.
Hope you have fun and enjoy simulating drafts on league of legends with AI controlled agents.

How the Draft Simulation Works

The DraftSimulator creates AI agents for each player on both teams.
It generates a random draft order.
For each pick:
- The current player's agent enters the THOUGHT state to analyze the current compositions.
- It may enter the ACTION state to perform further analysis.
- Finally, it enters the ANSWER state to make a champion pick.
The pick is announced through IRC, and the process continues until all positions are filled.

Execution Flow Example

The simulation starts when the IRC moderator joins the channel.
For each pick in the draft order:
- The current player's AI agent is activated.
- The agent thinks about the current team compositions.
- It may analyze the compositions further.
- The agent makes a champion pick.
- The pick is announced in the IRC channel.
This process repeats until all positions are filled for both teams.
The final team compositions are announced, and the simulation ends.

Final Considerations

The modular structure allows for easy modifications to the draft process or AI decision-making.
Error handling is implemented to deal with unexpected issues during the draft.
The simulation uses IRC for communication, making it possible to observe the draft in real-time using an IRC client.
The temperature setting (0.9) in the AI model allows for some creativity in picks while maintaining consistency.

Criando um Agente de IA ReAct com Node.js (pesquisa na Wikipedia ) pt-br

Allan Felipe Murara — Tue, 24 Sep 2024 16:01:19 +0000

Introdução

Vamos criar um agente de IA capaz de pesquisar na Wikipedia e responder perguntas com base nas informações coletadas.
Este Agente ReAct (Raciocínio e Ação) usa a API do Google Generative AI para processar consultas e gerar respostas.

Nosso agente será capaz de:

Pesquisar informações relevantes na Wikipedia.
Extrair seções específicas das páginas da Wikipedia.
Raciocinar sobre as informações coletadas e formular respostas.

[2] O que é um Agente ReAct?

Um Agente ReAct é um tipo específico de agente que segue um ciclo de Reflexão-Ação. Ele reflete sobre a tarefa atual, com base nas informações disponíveis e nas ações que pode realizar, e então decide qual ação tomar ou se deve concluir a tarefa.

[3] Planejando o Agente

3.1 Ferramentas Necessárias

Node.js
Biblioteca Axios para requisições HTTP
API do Google Generative AI (gemini-1.5-flash)
API da Wikipedia

3.2 Estrutura do Agente

Nosso Agente ReAct terá três estados principais:

THOUGHT (Reflexão)
ACTION (Execução)
ANSWER (Resposta)

3.3 Estado de Pensamento

O estado de pensamento é o momento em que o ReactAgent refletirá sobre as informações coletadas e decidirá qual deve ser o próximo passo.

async thought() {
    // ...
}

3.4 Estado de Ação (ACTION)

No estado de ação, o agente executa uma das funções disponíveis com base no Pensamento anterior.
Note que há a ação (execução) e a decisão (qual ação).

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] Implementando o Agente

Vamos construir o Agente ReAct passo a passo, destacando cada estado.

4.1 Configuração Inicial

Primeiro, configure o projeto e instale as dependências:

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

Crie um arquivo .env na raiz do projeto:

GOOGLE_AI_API_KEY=sua_chave_api_aqui

Chave de API GRATUITA aqui

4.2 Declaração de Funções

Este arquivo é o arquivo JavaScript que o Node.js usará para executar uma chamada de API para a Wikipedia.
Descrevemos o conteúdo deste arquivo em FunctionDescription.

Crie Tools.js com o seguinte conteúdo:

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 Criando o Arquivo ReactAgent.js

Crie ReactAgent.js com o seguinte conteúdo:

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 Executando o Agente e Explicando as Ferramentas Disponíveis (index.js)

Crie index.js com o seguinte conteúdo:

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

Descrição de Função

Ao tentar adicionar uma nova ferramenta ou função, certifique-se de descrevê-la bem.
Em nosso exemplo, isso já está feito e adicionado à nossa classe ReActAgent ao chamar uma nova Instância.

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] Como Funciona a Parte da Wikipedia

A interação com a Wikipedia é feita em duas etapas principais:

Pesquisa inicial (função wikipedia):
- Faz uma requisição para a API de pesquisa da Wikipedia.
- Retorna até 4 resultados relevantes para a consulta.
- Para cada resultado, busca as seções da página.
Pesquisa detalhada (função wikipedia_with_pageId):
- Usa o ID da página e o ID da seção para buscar conteúdo específico.
- Retorna o texto da seção solicitada.

Este processo permite que o agente primeiro obtenha uma visão geral dos tópicos relacionados à consulta e depois se aprofunde em seções específicas conforme necessário.

[6] Exemplo de Fluxo de Execução

O usuário faz uma pergunta.
O agente entra no estado THOUGHT e reflete sobre a pergunta.
Ele decide pesquisar na Wikipedia e entra no estado ACTION.
Executa a função wikipedia e obtém resultados.
Retorna ao estado THOUGHT para refletir sobre os resultados.
Pode decidir buscar mais detalhes ou uma abordagem diferente.
Repete o ciclo THOUGHT e ACTION conforme necessário.
Quando tem informações suficientes, entra no estado ANSWER.
Gera uma resposta final baseada em todas as informações coletadas.
Entra em loop infinito sempre que a Wikipedia não tiver os dados para coletar. Corrija isso com um temporizador =P

[7] Considerações Finais

A estrutura modular permite fácil adição de novas ferramentas ou APIs.
É importante implementar tratamento de erros e limites de tempo/iteração para evitar loops infinitos ou uso excessivo de recursos.
Este exemplo usa temperatura 2. Quanto menor a temperatura, menos criativo o agente se torna durante as iterações. Experimente para perceber a influência da temperatura nos LLMs.

Creating a ReAct AI Agent with nodeJS ( search wikipedia )

Allan Felipe Murara — Tue, 24 Sep 2024 01:59:26 +0000

Introduction

We'll create an AI agent capable of searching Wikipedia and answering questions based on the information it finds. This ReAct (Reason and Act) Agent uses the Google Generative AI API to process queries and generate responses. Our agent will be able to:

Search Wikipedia for relevant information.
Extract specific sections from Wikipedia pages.
Reason about the information gathered and formulate answers.

[2] What is a ReAct Agent?

A ReAct Agent is a specific type of agent that follows a Reflection-Action cycle. It reflects on the current task, based on available information and actions it can perform, and then decides which action to take or whether to conclude the task.

[3] Planning the Agent

3.1 Required Tools

Node.js
Axios library for HTTP requests
Google Generative AI API (gemini-1.5-flash)
Wikipedia API

3.2 Agent Structure

Our ReAct Agent will have three main states:

THOUGHT (Reflection)
ACTION (Execution)
ANSWER (Response)

3.3 Thought State

The thought state is the moment where the ReactAgent will reflect over the collected information and decide what should be the next step.

async thought() {
 .....
}

3.4 Action State (ACTION)

In the action state, the agent executes one of the available functions based on the previous Thought.
Note that there is the action ( execution ) and the decision ( which action ).

async action() {
 // call the decision 
 // execute the action and return a ActionResult
}

async decideAction() {
 // Call the llm based on the Thought ( reflection ) to format and adequate the functionCall.
}

[4] Implementing the Agent

Let's build the ReAct Agent step by step, highlighting each state.

4.1 Initial Setup

First, set up the project and install dependencies:

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

Create a .env file at the project's root:

GOOGLE_AI_API_KEY=your_api_key_here

FREE ApiKey here

4.2 Function Declaration

This file is the Javascript file that NodeJS will use for actually executing an api call to Wikipedia.
We describe the content of this file at FunctionDescription.

Create Tools.js with the following content:

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 Creating the ReactAgent.js File

Create ReactAgent.js with the following content:

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

//Play around with the prompt to perceive the differences.
//Feel free to comment asking for guidance if anything.
//Improving the thought part can be as simple as adding two lines to the beginning of the prompt, finally becoming :  

//Your task to FullFill ${this.query}.
//If you already have an answer for the task, you can go ahead and FullFill it.
//Otherwise you act accordingly to the following scenario >>>


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}`);
    return finalAnswer;
  }
}

module.exports = ReActAgent;

4.4 Running the agent and explaining the available tools (index.js)

Create index.js with the following content:

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

async function main() {
  const query = "What does England border with?";
  // const query = "what are the neighbourhoods of Joinville?";
  // const query = "what is the capital of France?";
  // const query = "What does england borders with?";
  // const query = "what is the color of the sky?";
  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);

Function description

Whenever trying to add a new tool or function make sure to describe it well.
At our example, this is already done, and added to our class ReActAgent while calling a new Instance.

const functions = [
    [
      "google", //functionName
      "params: query", //LocalParamsName
      "Semantic Search Wikipedia API for snippets, pageIds and sectionIds >> \n ex: Date brazil has been colonized? \n Brazil was colonized at 1500, pageId, sections : []", // briefly explanation and example (this will be forward to the LLM)
    ]

[5] How the Wikipedia Part Works

The interaction with Wikipedia is done in two main steps:

Initial search (wikipedia function):
- Makes a request to the Wikipedia search API.
- Returns up to 4 relevant results for the query.
- For each result, it fetches the sections of the page.
Detailed search (wikipedia_with_pageId function):
- Uses the page ID and section ID to fetch specific content.
- Returns the text of the requested section.

This process allows the agent to first get an overview of topics related to the query and then dive deeper into specific sections as needed.

[6] Execution Flow Example

The user asks a question.
The agent enters the THOUGHT state and reflects on the question.
It decides to search Wikipedia and enters the ACTION state.
Executes the wikipedia function and obtains results.
Returns to the THOUGHT state to reflect on the results.
May decide to search for more details or a different approach.
Repeats the THOUGHT and ACTION cycle as necessary.
When it has sufficient information, it enters the ANSWER state.
Generates a final answer based on all the information collected.
Enters infinite loop whenever the wikipedia doesn't have the data to collect. Fix it with a timer =P

[7] Final Considerations

The modular structure allows for easy addition of new tools or APIs.
It's important to implement error handling and time/iteration limits to avoid infinite loops or excessive resource use.
This example uses temperature 2. The smaller the temperature, the less creative during turns this agent becomes. Play around with it to perceive the influence of temperature in llms.
For a "real deal" functionCalling Look around for a function-tool mode at google dapi docs

DEV Community: Allan Felipe Murara

Causality — Transformers Theory

Creating Multi Agents with NodeJS ( Talk itself into a League of legends Draft with NodeJS )

Introduction

What is a ReAct Agent?

Agent Structure

Let's Convert this Agent into MultiAgents and the DraftModerator and let the Talk start!!

[1] Initial Setup

1. Create a .env file at the project's root:

2. ReActAgent.js

3. players.js

4. DraftSimulator.js

5. index.js:

Running the Simulation

How the Draft Simulation Works

Execution Flow Example

Final Considerations

Criando um Agente de IA ReAct com Node.js (pesquisa na Wikipedia ) pt-br

Introdução

[2] O que é um Agente ReAct?

[3] Planejando o Agente

3.1 Ferramentas Necessárias

3.2 Estrutura do Agente

3.3 Estado de Pensamento

3.4 Estado de Ação (ACTION)

[4] Implementando o Agente

4.1 Configuração Inicial

4.2 Declaração de Funções

4.3 Criando o Arquivo ReactAgent.js

4.4 Executando o Agente e Explicando as Ferramentas Disponíveis (index.js)

Descrição de Função

[5] Como Funciona a Parte da Wikipedia

[6] Exemplo de Fluxo de Execução

[7] Considerações Finais

Creating a ReAct AI Agent with nodeJS ( search wikipedia )

Introduction

[2] What is a ReAct Agent?

[3] Planning the Agent

3.1 Required Tools

3.2 Agent Structure

3.3 Thought State

3.4 Action State (ACTION)

[4] Implementing the Agent

4.1 Initial Setup

4.2 Function Declaration

4.3 Creating the ReactAgent.js File

4.4 Running the agent and explaining the available tools (index.js)

Function description

[5] How the Wikipedia Part Works

[6] Execution Flow Example

[7] Final Considerations

1. Create a `.env` file at the project's root: