Démo en direct
Rejoignez notre communauté Discord : AI Stack Devs
AI Town est une ville virtuelle où les personnages IA vivent, discutent et socialisent.
Ce projet est un kit de démarrage déployable pour créer et personnaliser facilement votre propre version d'AI town. Inspiré par le document de recherche Generative Agents: Interactive Simulacra of Human Behavior .
L'objectif principal de ce projet, au-delà du simple fait d'être très amusant sur lequel travailler, est de fournir une plate-forme dotée d'une base solide qui est destinée à être étendue. Le back-end prend en charge de manière native l'état global partagé, les transactions et un moteur de simulation et devrait convenir à tout, depuis un simple projet avec lequel jouer jusqu'à un jeu multijoueur évolutif. Un objectif secondaire est de rendre disponible un framework JS/TS, car la plupart des simulateurs de cet espace (y compris l'article original ci-dessus) sont écrits en Python.
llama3 et les intégrations avec mxbai-embed-large .Remarque : Il existe une installation en un clic d'un fork de ce projet sur Pinokio pour toute personne intéressée à l'exécuter mais pas à le modifier ?
git clone https://github.com/a16z-infra/ai-town.git
cd ai-town
npm installSoit téléchargez un binaire prédéfini (recommandé), soit créez-le à partir des sources et exécutez-le.
# For new Macs:
curl -L -O https://github.com/get-convex/convex-backend/releases/latest/download/convex-local-backend-aarch64-apple-darwin.zip
unzip convex-local-backend-aarch64-apple-darwin.zip
brew install just
# Runs the server
./convex-local-backend Cela s'installe également just (par exemple, brew install just ou cargo install just ). Nous utilisons just like make pour ajouter des paramètres supplémentaires, vous exécutez donc just convex ... au lieu de npx convex ... pour le développement local.
Si vous exécutez le binaire prédéfini sur Mac et qu'il y a un avertissement Apple, accédez au dossier dans lequel il se trouve, cliquez dessus avec le bouton droit et sélectionnez « Ouvrir » pour le contourner. À partir de là, vous pouvez l'exécuter depuis la ligne de commande. Ou vous pouvez le compiler à partir des sources et l'exécuter (voir ci-dessus).
Vous pouvez laisser l'application en cours d'exécution ou exécuter ollama serve . ollama serve vous avertira si l'application est déjà en cours d'exécution. Exécutez ollama pull llama3 pour le télécharger llama3 . Testez-le avec ollama run llama3 . Si vous souhaitez personnaliser le modèle à utiliser, ajustez convex/util/llm.ts ou définissez just convex env set LLM_MODEL # model . Les options de modèles Ollama peuvent être trouvées ici.
Vous souhaiterez peut-être définir NUM_MEMORIES_TO_SEARCH sur 1 dans constants.ts, pour réduire la taille des invites de conversation, si vous constatez une lenteur.
Consultez convex/config.ts pour configurer les modèles à proposer à l'interface utilisateur ou pour le configurer pour communiquer avec un LLM hébergé dans le cloud.
Pour la génération quotidienne de musique de fond, créez un compte Répliquer et créez un jeton sur la page Jeton API de votre profil. just convex env set REPLICATE_API_TOKEN # token
Pour exécuter à la fois le front-end et le back-end :
npm run dev Remarque : Si vous rencontrez une erreur de version de nœud sur le serveur convexe au démarrage de l'application, veuillez utiliser la version 18 du nœud, qui est la plus stable. Une façon de procéder consiste à installer nvm et à exécuter nvm install 18 ou nvm use 18 . Faites-le avant que le npm run dev ci-dessus et le ./convex-local-backend à l'étape 2.
Vous pouvez maintenant visiter http://localhost:5173.
Si vous préférez exécuter le frontend dans un terminal distinct de Convex (qui synchronise vos fonctions backend au fur et à mesure de leur enregistrement), vous pouvez exécuter ces deux commandes :
npm run dev:frontend
npm run dev:backend Voir package.json pour plus de détails, mais dev:backend exécute just convex dev
Remarque : La simulation s'arrêtera au bout de 5 minutes si la fenêtre est inactive. Le chargement de la page la réactivera. Vous pouvez également geler et débloquer manuellement le monde avec un bouton dans l'interface utilisateur. Si vous souhaitez exécuter le monde sans le navigateur, vous pouvez commenter le cron "arrêter les mondes inactifs" dans convex/crons.ts .
Pour arrêter le back-end, en cas de trop d'activité
Cela arrêtera de faire fonctionner le moteur et les agents. Vous pouvez toujours exécuter des requêtes et exécuter des fonctions pour déboguer.
just convex run testing:stopPour redémarrer le back-end après l'avoir arrêté
just convex run testing:resumePour lancer le moteur au cas où le moteur de jeu ou les agents ne fonctionneraient pas
just convex run testing:kickPour archiver le monde
Si vous souhaitez réinitialiser le monde et repartir de zéro, vous pouvez archiver le monde actuel :
just convex run testing:archiveEnsuite, vous pouvez toujours consulter les données mondiales dans le tableau de bord, mais le moteur et les agents ne fonctionneront plus.
Vous pouvez ensuite créer un nouveau monde avec init .
just convex run initPour effacer toutes les bases de données
Vous pouvez effacer toutes les tables avec la fonction de test wipeAllTables .
just convex run testing:wipeAllTablesPour suspendre votre déploiement backend
Vous pouvez accéder au tableau de bord dans vos paramètres de déploiement pour suspendre et reprendre votre déploiement. Cela arrêtera toutes les fonctions, qu'elles soient invoquées depuis le client, planifiées ou en tant que tâche cron. Considérez cela comme un dernier recours, car il existe des moyens plus doux de s'arrêter au-dessus. Une fois que vous
Modifiez votre fichier package.json pour ajouter l'option --host à votre serveur frontal (Vite) :
{
"name" : " ai-town " ,
"version" : " 0.0.0 " ,
"private" : true ,
"scripts" : {
"dev" : " npm-run-all --parallel dev:frontend dev:backend " ,
"build" : " tsc && vite build " ,
"lint" : " eslint . " ,
"predev" : " just convex dev --run init --until-success " ,
"dev:backend" : " just convex dev --tail-logs " ,
"dev:frontend" : " vite --host " , // <------------------------------------------ modify this line
"test" : " NODE_OPTIONS=--experimental-vm-modules jest --verbose " ,
"le" : " vite src/editor/ "
}
}Exécutez la commande suivante pour lancer Docker Compose :
docker-compose up --buildUne fois terminé, vous pouvez fermer le terminal.
Dans un autre terminal, toujours dans le répertoire aitown , lancez un terminal Docker interactif :
docker-compose exec ai-town /bin/bashTéléchargez et décompressez le backend Convex local :
curl -L -O https://github.com/get-convex/convex-backend/releases/download/precompiled-2024-06-28-91981ab/convex-local-backend-x86_64-unknown-linux-gnu.zip
unzip convex-local-backend-x86_64-unknown-linux-gnu.zip Vérifiez que le fichier convex-local-backend se trouve dans le répertoire, puis supprimez le fichier zip :
rm convex-local-backend-x86_64-unknown-linux-gnu.zipRendre le fichier exécutable :
chmod +x /usr/src/app/convex-local-backendLancez le serveur backend Convex :
./convex-local-backend Dans un autre terminal, dans le répertoire aitown , relancez :
docker-compose exec ai-town /bin/bash Configurez socat avec l'adresse IP de l'hôte :
HOST_IP=YOUR-HOST-IP # Use your host's IP address (not the Docker IP)
socat TCP-LISTEN:11434,fork TCP: $HOST_IP :11434 &Testez la connexion :
curl http://localhost:11434/S'il est écrit "Ollama court", c'est bien !
Assurez-vous que Convex sait où trouver Ollama (pour éviter un bug mystérieux aléatoire...) :
just convex env set OLLAMA_HOST http://localhost:11434Mettez à jour la liste des navigateurs :
npx update-browserslist-db@latestLancez AI Town :
npm run devlancez le conteneur puis ouvrez simplement deux terminaux dans votre dossier AI-town avec docker-compose exec ai-town /bin/bash
Lancez le serveur backend Convex : bash ./convex-local-backend Et dans le deuxième terminal, configurez simplement Socat, lancez AI Town.
Tout d’abord, vous devez installer WSL2. Suivez ce guide pour configurer WSL2 sur votre ordinateur Windows. Nous vous recommandons d'utiliser Ubuntu comme distribution Linux.
Ouvrez votre terminal WSL (Ubuntu) et mettez à jour vos packages :
sudo apt update
NVM (Node Version Manager) permet de gérer plusieurs versions de Node.js. Installez NVM et Node.js 18 (la version stable) :
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.2/install.sh | bash
export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"
source ~/.bashrc
nvm install 18
nvm use 18
Python est requis pour certaines dépendances. Installez Python et Pip :
sudo apt-get install python3 python3-pip
sudo ln -s /usr/bin/python3 /usr/bin/python
Installez unzip et socat :
sudo apt install unzip socat
Cargo est le gestionnaire de packages Rust. Installez Rust et Cargo :
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env
just avec Cargo just est utilisé pour exécuter des commandes. Installez-le avec Cargo :
cargo install just
export PATH="$HOME/.cargo/bin:$PATH"
just --version
socat pour ponter les ports pour OllamaExécutez la commande suivante pour relier les ports, permettant ainsi la communication entre Convex et Ollama :
socat TCP-LISTEN:11434,fork TCP:$(cat /etc/resolv.conf | grep nameserver | awk '{print $2}'):11434 &
Teste si ça marche :
curl http://127.0.0.1:11434
S'il répond OK, l'API Ollama est accessible.
Clonez le dépôt AI Town depuis GitHub :
git clone https://github.com/a16z-infra/ai-town.git
cd ai-town
Installez les packages npm nécessaires :
npm install
Téléchargez et installez la version précompilée de Convex :
curl -L -O https://github.com/get-convex/convex-backend/releases/download/precompiled-2024-06-28-91981ab/convex-local-backend-x86_64-unknown-linux-gnu.zip
unzip convex-local-backend-x86_64-unknown-linux-gnu.zip
rm convex-local-backend-x86_64-unknown-linux-gnu.zip
chmod +x convex-local-backend
Dans un terminal séparé, lancez Convex :
./convex-local-backend
Définissez l'hôte Ollama en Convex :
just convex env set OLLAMA_HOST http://localhost:11434
Enfin, lancez AI Town :
npm run dev
Visitez http://localhost:5173 dans votre navigateur pour voir AI Town en action.
Si vous devez redémarrer les services :
Assurez-vous socat est en cours d'exécution :
socat TCP-LISTEN:11434,fork TCP:$(cat /etc/resolv.conf | grep nameserver | awk '{print $2}'):11434 &
Lancez Convexe :
./convexe-local-backend
Dans un autre terminal : 3. Lancez AI Town :
npm run dev
REMARQUE : chaque fois que vous modifiez les données de caractères, vous devez réexécuter just convex run testing:wipeAllTables , puis npm run dev pour tout télécharger à nouveau sur Convex. En effet, les données de caractères sont envoyées à Convex lors du chargement initial. Cependant, sachez que just convex run testing:wipeAllTables effacera toutes vos données.
Créez vos propres personnages et histoires : tous les personnages et histoires, ainsi que leurs références de feuille de sprite, sont stockés dans caractères.ts. Vous pouvez commencer par modifier les descriptions des personnages.
Mise à jour des spritesheets : dans data/characters.ts , vous verrez ce code :
export const characters = [
{
name : 'f1' ,
textureUrl : '/assets/32x32folk.png' ,
spritesheetData : f1SpritesheetData ,
speed : 0.1 ,
} ,
...
] ; Vous devriez trouver une feuille de sprite pour votre personnage et définir le mouvement/les ressources du sprite dans le fichier correspondant (dans l'exemple ci-dessus, f1SpritesheetData a été défini dans f1.ts)
Mettre à jour l'arrière-plan (environnement) : la carte est chargée dans convex/init.ts à partir de data/gentle.js . Pour mettre à jour la carte, procédez comme suit :
convertMap.js pour convertir le JSON dans un format que le moteur peut utiliser. node data/convertMap.js <mapDataPath> <assetPath> <tilesetpxw> <tilesetpxh><mapDataPath> : Chemin d'accès au fichier JSON en mosaïque.<assetPath> : Chemin d’accès aux images du jeu de tuiles.<tilesetpxw> : Largeur du jeu de tuiles en pixels.<tilesetpxh> : Hauteur du jeu de tuiles en pixels. Génère converted-map.js que vous pouvez utiliser comme gentle.jsconvex/music.tsconvex/crons.ts en modifiant la tâche generate new background music Configurez convex/util/llm.ts ou définissez ces variables d'environnement :
just convex env set LLM_API_HOST # url
just convex env set LLM_MODEL # modelLa configuration du modèle d'intégration doit être modifiée dans le code, car vous devez spécifier la dimension d'intégration.
Pour Together.ai, visitez https://api.together.xyz/settings/api-keys Pour OpenAI, visitez https://platform.openai.com/account/api-keys
Vous pouvez exécuter votre backend Convex dans le cloud en exécutant simplement
npx convex dev --until-success --configure Et mettre à jour les scripts package.json pour supprimer just : changer just convex ... en convex ... .
Vous devrez ensuite définir toutes les variables d'environnement que vous aviez localement dans l'environnement cloud avec npx convex env set ou sur le tableau de bord : https://dashboard.convex.dev/deployment/settings/environment-variables
Avant de pouvoir exécuter l'application, vous devrez vous assurer que les fonctions Convex sont déployées dans son environnement de production.
npx convex deploy pour déployer les fonctions convexes en productionnpx convex run init --prod Si vous souhaitez effacer des données existantes, vous pouvez exécuter npx convex run testing:wipeAllTables --prod
Vous pouvez rajouter l'authentification du commis avec git revert b44a436 . Ou regardez simplement cette différence pour savoir ce qui a changé pour la supprimer.
Créer un compte de commis
VITE_CLERK_PUBLISHABLE_KEY et CLERK_SECRET_KEY à .env.local VITE_CLERK_PUBLISHABLE_KEY=pk_ ***
CLERK_SECRET_KEY=sk_ ***just convex env set CLERK_ISSUER_URL # e.g. https://your-issuer-url.clerk.accounts.dev/vercel login .vercel --prod . Nous soutenons l'utilisation d'Ollama pour les générations de conversations. Pour le rendre accessible depuis le Web, vous pouvez utiliser Tunnelmole ou Ngrok ou similaire.
Utiliser Tunnelmole
Tunnelmole est un outil de tunneling open source.
Vous pouvez installer Tunnelmole en utilisant l'une des options suivantes :
npm install -g tunnelmolecurl -s https://tunnelmole.com/sh/install-linux.sh | sudo bashcurl -s https://tunnelmole.com/sh/install-mac.sh --output install-mac.sh && sudo bash install-mac.shexe pour Windows ici et placez-le quelque part dans votre PATH.Une fois Tunnelmole installé, exécutez la commande suivante :
tmole 11434
Tunnelmole devrait générer une URL unique une fois que vous exécutez cette commande.
Utiliser Ngrok
Ngrok est un outil de tunneling source fermé populaire.
Une fois ngrok installé et authentifié, exécutez la commande suivante :
ngrok http http://localhost:11434
Ngrok devrait générer une URL unique une fois que vous exécutez cette commande.
Ajouter le point de terminaison Ollama à Convex
just convex env set OLLAMA_HOST # your tunnelmole/ngrok unique url from the previous stepMettre à jour les domaines Ollama
Ollama a une liste de domaines acceptés. Ajoutez le domaine ngrok pour qu'il ne rejette pas le trafic. voir ollama.ai pour plus de détails.
Convex est une plate-forme backend hébergée avec une base de données intégrée qui vous permet d'écrire votre schéma de base de données et vos fonctions de serveur en TypeScript. Les requêtes de base de données côté serveur mettent automatiquement en cache et s'abonnent aux données, alimentant un hook useQuery en temps réel dans notre client React. Il existe également des clients pour Python, Rust, ReactNative et Node, ainsi qu'une API HTTP simple.
La base de données prend en charge les documents de style NoSQL avec validation de schéma opt-in, relations et index personnalisés (y compris sur les champs des objets imbriqués).
Les fonctions du serveur query et mutation ont un accès transactionnel à faible latence à la base de données et exploitent notre environnement d'exécution v8 avec des garde-fous de déterminisme pour fournir les garanties ACID les plus solides du marché : cohérence immédiate, isolation sérialisable et résolution automatique des conflits via un contrôle de concurrence multi-version optimiste. (OCC/MVCC).
Les fonctions du serveur action ont accès à des API externes et permettent d'autres effets secondaires et non-déterminisme dans notre environnement d'exécution v8 optimisé ou dans un environnement d'exécution node plus flexible.
Les fonctions peuvent s'exécuter en arrière-plan via des tâches de planification et cron.
Le développement est axé sur le cloud, avec des rechargements à chaud pour l'édition des fonctions du serveur via la CLI, des déploiements en aperçu, des intégrations de journalisation et de rapport d'exception. Il existe une interface utilisateur de tableau de bord pour parcourir et modifier les données, modifier les variables d'environnement, afficher les journaux, exécuter les fonctions du serveur, etc. .
Il existe des fonctionnalités intégrées pour la pagination réactive, le stockage de fichiers, la recherche de texte réactive, la recherche de vecteurs, les points de terminaison https (pour les webhooks), l'importation/exportation d'instantanés, l'importation/exportation en streaming et la validation d'exécution pour les arguments de fonction et les données de base de données.
Tout évolue automatiquement et le démarrage est gratuit.
