Lecteur, prends garde à toi

• ce code est très peu commenté alors qu'il fait de tours et des détours parfois compliqués à suivre, ce qui constitue d'ailleurs l'une des raisons pour lesquelles le présent article a été écrit – vu son intérêt pédagogique, il fallait rendre ce code accessible à tous ;
• dans cet article, ce code sera grandement détaillé, mais pas dans ses moindres détails – notamment ce qui concerne les checkpoints –, si bien que les explications seront plus faciles à suivre si l'on se reporte parallèlement au code, qui est donc en accès libre sur un repo de GitHub.

Question 1: How to obtain a diamond ore?
<réponse>

Alex ou Steve, avec un cerveau

Le mécanisme, à gros traits

• Un automatic curriculum, qui consiste à demander au LLM de générer la description de la prochaine tâche à accomplir dans l'objectif déjà mentionné – accomplir le plus de tâches possibles pour devenir le meilleur joueur de Minecraft au monde – sur la base d'une description de l'état de l'agent et de son environnement. La description générée est en langage naturel, mentionnant par exemple "Obtain a wood log".
• Un iterative prompting mechanism, qui consiste à demander au LLM de générer le code JavaScript qui permet de contrôler l'agent dans Minecraft, en s'appuyant au besoin sur du code déjà stocké dans une bibliothèque. Ce code est vérifié par un interpréteur JavaScript, et exécuté s'il est valide. Sur la base du retour de l'interpréteur et de Minecraft, le LLM est alors interrogé pour lui demander d'évaluer si le code a permis d'accomplir la tâche, et de reprendre tout le processus si ce n'est pas le cas.
• Une skill library, qui correspond donc à la bibliothèque évoquée, et qui n'est autre qu'une base de données vectorielle qui permet d'associer la description d'une tâche au code JavaScript dont le LLM a précédemment validé qu'il s'exécutait et permettait d'accomplir la tâche en question.

UN GRAND TOUR SOUS LE CAPOT

Que la fête commence !

from voyager import Voyager

# You can also use mc_port instead of azure_login, but azure_login is highly recommended
azure_login = {
	"client_id": "YOUR_CLIENT_ID",
	"redirect_url": "https://127.0.0.1/auth-response",
	"secret_value": "[OPTIONAL] YOUR_SECRET_VALUE",
	"version": "fabric-loader-0.14.18-1.19", # the version Voyager is tested on
}
openai_api_key = "YOUR_API_KEY"

voyager = Voyager(
	azure_login=azure_login,
	openai_api_key=openai_api_key,
)

# start lifelong learning
voyager.learn()

bot = mineflayer.createBot({
	host: "localhost", // minecraft server ip
	port: req.body.port, // minecraft server port
	username: "bot",
	disableChatSigning: true,
	checkTimeoutInterval: 60 * 60 * 1000,
});

• le "serveur" Minecraft qui tourne en local, à l'écoute vraisemblablement sur le port 25565 ;
• un serveur HTTP à l'écoute sur le port 3000, qui attend des requêtes pour créer et contrôler le bot via Mineflayer, qui traduit des appels à son API en messages envoyés au "serveur" Minecraft ;
• des méthodes .reset () pour relancer tout ça.

Alex, ma soeur Alex, que vois-tu à l'horizon ?

obs.inject(bot, [
	OnChat,
	OnError,
	Voxels,
	Status,
	Inventory,
	OnSave,
	Chests,
	BlockRecords,
]);

class Voxels extends Observation {
	constructor(bot) {
		super(bot);
		this.name = "voxels";
	}

	observe() {
		return Array.from(getSurroundingBlocks(this.bot, 8, 2, 8));
	}
}

{ <paramètre>:  <valeur>, ... }

{ <nom>: <nombre>, ... }

{ <position>: { <nom>: <nombre>, ... }, ... }

z<position>: "Unknown"

[ <nom>, ... ]

[ <nom>, ... ]

class onError extends Observation {
	constructor(bot) {
		super(bot);
		this.name = "onError";
		this.obs = null;
		bot.on("error", (err) => {
			// Save entity status to local variable
			this.obs = err;
			this.bot.event(this.name);
		});
	}

	observe() {
		const result = this.obs;
		this.obs = null;
		return result;
	}
}

function inject(bot, obs_list) {
	bot.obsList = [];
	bot.cumulativeObs = [];
	bot.eventMemory = {};
	obs_list.forEach((obs) => {
		bot.obsList.push(new obs(bot));
	});
	bot.event = function (event_name) {
		let result = {};
		bot.obsList.forEach((obs) => {
			if (obs.name.startsWith("on") && obs.name !== event_name) {
				return;
			}
			result[obs.name] = obs.observe();
		});
		bot.cumulativeObs.push([event_name, result]);
	};
	bot.observe = function () {
		bot.event("observe");
		const result = bot.cumulativeObs;
		bot.cumulativeObs = [];
		return JSON.stringify(result);
	};
}

• bot.event () appelle la méthode .observe () de chacun des objets évoqués à l'instant, sauf si le nom de la classe est formé du préfixe "on" suivi du nom d'un événement différent de celui qui lui est passé, et stocke le résultat dans un dictionnaire. Bref, bot.event () stocke systématiquement ce que retourne la méthode .observe () de Status, Inventory, Chests,Voxels et BlockRecords, et éventuellement ce que retourne celle de onChatonError et onSave selon qu'elle est appelée par bot.event ("onChat"), bot.event ("onError") ou bot.event ("onSave"). Pour finir, elle rajoute un petit tableau de deux entrées – le nom de l'événement qui lui a été passé, et ce dictionnaire – à un tableau, bot.cumulativeObs.
• bot.observe () appelle bot.event () au prétexte d'un événement "observe", et retourne le produit de la sérialisation en JSON de bot.cumulativeObs, qu'elle purge alors.

[
	[
		<event_name>,	// "observe", "onChat", "onError" ou "onSave"
		{
			voxels: <résultat retourné par Voxels.observe ()>,
			status: <résultat retourné par Status.observe ()>,
			inventory: <résultat retourné par Inventory.observe ()>,
			nearbyChests: <résultat retourné par Chests.observe ()>
			blockRecords: <résultat retourné par BlockRecords.observe ()>,
			on<event_name>:	<résultat retourné par on<event_name>.observe ()>
		}
	]
	...
]

Entrent les agents

self.llm = ChatOpenAI(
	model_name=model_name,
	temperature=temperature,
	request_timeout=request_timout,
)

langchain_openai.ChatOpenAI
langchain_anthropic.ChatAnthropic
langchain_mistralai.ChatMistralAI
...

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOpenAI(openai_api_key="...")
prompt = ChatPromptTemplate.from_messages([
	("system", "You are world class technical documentation writer."),
	("user", "{input}")
])
output_parser = StrOutputParser()
chain = prompt | llm | output_parser
chain.invoke({"input": "how can langsmith help with testing?"})

class Runnable(Generic[Input, Output], ABC):
	//...
	def pipe(
		self,
		*others: Union[Runnable[Any, Other], Callable[[Any], Other]],
		name: Optional[str] = None,
	) -> RunnableSerializable[Input, Other]:
		//...
	//...

self.vectordb = Chroma(
	collection_name="skill_vectordb",
	embedding_function=OpenAIEmbeddings(),
	persist_directory=f"{ckpt_dir}/skill/vectordb",
)

from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma

embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
vector_store = Chroma(
	collection_name="example_collection",
	embedding_function=embeddings,
	persist_directory="./chroma_langchain_db",  # Where to save data locally, remove if not neccesary
)

from uuid import uuid4
from langchain_core.documents import Document

document_1 = Document(
	page_content="I had chocolate chip pancakes and scrambled eggs for breakfast this morning.",
	metadata={"source": "tweet"},
	id=1,
)
...
documents = [
	document_1,
	...
]
uuids = [str(uuid4()) for _ in range(len(documents))]
vector_store.add_documents(documents=documents, ids=uuids)

results = vector_store.similarity_search(
	"LangChain provides abstractions to make working with LLMs easy",
	k=2,
	filter={"source": "tweet"},
)
for res in results:
	print(f"* {res.page_content} [{res.metadata}]")

L'essentiel, c'est la boucle

• la première est déroulée un nombre de fois par défaut fixé à 160 ;
• la seconde est déroulée tant que Voyager.step () ne signale pas qu'elle doit s'arrêter.

{
	"code": code,
	"programs": programs,
}

let response_sent = false;
function otherError(err) {
	console.log("Uncaught Error");
	bot.emit("error", handleError(err));
	bot.waitForTicks(bot.waitTicks).then(() => {
		if (!response_sent) {
			response_sent = true;
			res.json(bot.observe());
		}
	});
}

process.on("uncaughtException", otherError)

const bot = new EventEmitter()

[
	<event_name>,	// Ici, "onError"
	{
		voxels: <résultat retourné par Voxels.observe ()>,
		status: <résultat retourné par Status.observe ()>,
		inventory: <résultat retourné par Inventory.observe ()>,
		nearbyChests: <résultat retourné par Chests.observe ()>
		blockRecords: <résultat retourné par BlockRecords.observe ()>,
		onError:	<résultat retourné par onError.observe ()>
	}
]

Une IA assistée, qui n'hésite pas à tricher ?

function onTick() {
	bot.globalTickCounter++;
	if (bot.pathfinder.isMoving()) {
		bot.stuckTickCounter++;
		if (bot.stuckTickCounter >= 100) {
			onStuck(1.5);
			bot.stuckTickCounter = 0;
		}
	}
}
bot.on("physicTick", onTick);

function onStuck(posThreshold) {
	const currentPos = bot.entity.position;
	bot.stuckPosList.push(currentPos);

	// Check if the list is full
	if (bot.stuckPosList.length === 5) {
		const oldestPos = bot.stuckPosList[0];
		const posDifference = currentPos.distanceTo(oldestPos);

		if (posDifference < posThreshold) {
			teleportBot(); // execute the function
		}

		// Remove the oldest time from the list
		bot.stuckPosList.shift();
	}
}

• elle réside pour partie dans un programme extérieur déterministe comme le module mineflayer-pathfinder spécialisé dans le calcul d'itinéraires ;
• elle réside aussi pour partie dans le programme même de Voyager, qui tente de détecter un comportement erroné et de le corriger en trichant – on ne se téléporte pas sans Eye of Ender dans Minecraft !

Un dernier cadeau au bot avant de rendre la main

bot.on("physicTick", onTick);
const code = req.body.code;
const programs = req.body.programs;
bot.cumulativeObs = [];
const r = await evaluateCode(code, programs);
process.off("uncaughtException", otherError);
if (r !== "success") {
	bot.emit("error", handleError(r));
}
await returnItems();
// wait for last message
await bot.waitForTicks(bot.waitTicks);
if (!response_sent) {
	response_sent = true;
	res.json(bot.observe());
}
bot.removeListener("physicTick", onTick);

• elle cherche un établi et un four à une distance maximale de 128 blocs, et si elle trouve l'un de ces objets, elle le détruit – sans que cela entraîne un drop de l'objet, car elle a désactivé cette règle du jeu temporairement via un message "/gamerule doTileDrops false" écrit dans le chat – et le donne au bot ;
• si l'inventaire du bot comprend plus de 32 objets, et qu'il ne comporte pas de coffre, elle lui donne un coffre ;
• si un drapeau bot.iron_pickaxe, qui est initialisé à false, a toujours cette valeur et que le bot n'a pas de pioche en fer, elle lui en donne une – rien dans le code JavaScript de Voyager ne permet de constater que ce drapeau peut être passé à true.