Demostración en vivo
Únase a nuestra comunidad Discord: AI Stack Devs
AI Town es una ciudad virtual donde los personajes de AI viven, charlan y socializan.
Este proyecto es un kit de inicio desplegable para construir y personalizar fácilmente su propia versión de AI town. Inspirado en el trabajo de investigación Agentes generativos: simulacros interactivos del comportamiento humano .
El objetivo principal de este proyecto, más allá de ser muy divertido trabajar en él, es proporcionar una plataforma con una base sólida que debe ampliarse. El back-end admite de forma nativa el estado global compartido, las transacciones y un motor de simulación y debería ser adecuado para todo, desde un proyecto simple para jugar hasta un juego escalable para varios jugadores. Un objetivo secundario es hacer que un marco JS/TS esté disponible, ya que la mayoría de los simuladores en este espacio (incluido el artículo original anterior) están escritos en Python.
llama3 e incrustaciones con mxbai-embed-large .Nota : ¿Existe una instalación con un solo clic de una bifurcación de este proyecto en Pinokio para cualquiera que esté interesado en ejecutarlo pero no modificarlo?
git clone https://github.com/a16z-infra/ai-town.git
cd ai-town
npm installDescargue un binario prediseñado (recomendado) o compílelo desde el código fuente y ejecútelo.
# 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 Esto también instala just (por ejemplo, brew install just o cargo install just ). Usamos just make para agregar parámetros adicionales, por lo que ejecuta just convex ... en lugar de npx convex ... para el desarrollo local.
Si está ejecutando el binario prediseñado en Mac y hay una advertencia de Apple, vaya a la carpeta en la que se encuentra, haga clic derecho y seleccione "Abrir" para omitirlo. A partir de ese momento podrás ejecutarlo desde la línea de comandos. O puede compilarlo desde el código fuente y ejecutarlo (ver arriba).
Puedes dejar la aplicación ejecutándose o ejecutar ollama serve . ollama serve te avisará si la aplicación ya se está ejecutando. Ejecute ollama pull llama3 para que descargue llama3 . Pruébelo con ollama run llama3 . Si desea personalizar qué modelo usar, ajuste convex/util/llm.ts o configure just convex env set LLM_MODEL # model . Las opciones del modelo Ollama se pueden encontrar aquí.
Es posible que desees establecer NUM_MEMORIES_TO_SEARCH en 1 en constantes.ts, para reducir el tamaño de las indicaciones de la conversación, si ves lentitud.
Consulte convex/config.ts para configurar qué modelos ofrecer a la interfaz de usuario o configurarlo para comunicarse con un LLM alojado en la nube.
Para la generación diaria de música de fondo, cree una cuenta replicada y cree un token en la página Token API de su perfil. just convex env set REPLICATE_API_TOKEN # token
Para ejecutar tanto el front-end como el back-end:
npm run dev Nota : Si encuentra un error de versión de nodo en el servidor convexo al iniciar la aplicación, utilice la versión 18 del nodo, que es la más estable. Una forma de hacerlo es instalando nvm y ejecutando nvm install 18 o nvm use 18 . Haga esto antes de que npm run dev arriba y ./convex-local-backend en el Paso 2.
Ahora puede visitar http://localhost:5173.
Si prefiere ejecutar la interfaz en una terminal separada de Convex (que sincroniza las funciones de su backend a medida que se guardan), puede ejecutar estos dos comandos:
npm run dev:frontend
npm run dev:backend Consulte package.json para obtener más detalles, pero dev:backend ejecuta just convex dev
Nota : La simulación se detendrá después de 5 minutos si la ventana está inactiva. Al cargar la página se reanudará la pausa. También puedes congelar y descongelar el mundo manualmente con un botón en la interfaz de usuario. Si desea ejecutar el mundo sin el navegador, puede comentar el cron "detener mundos inactivos" en convex/crons.ts .
Para detener la parte trasera, en caso de demasiada actividad.
Esto dejará de hacer funcionar el motor y los agentes. Aún puede ejecutar consultas y ejecutar funciones para depurar.
just convex run testing:stopPara reiniciar el backend después de detenerlo
just convex run testing:resumePara iniciar el motor en caso de que el motor del juego o los agentes no estén funcionando
just convex run testing:kickPara archivar el mundo
Si desea restablecer el mundo y empezar desde cero, puede archivar el mundo actual:
just convex run testing:archiveEntonces, aún podrá ver los datos del mundo en el panel, pero el motor y los agentes ya no funcionarán.
Luego puedes crear un mundo nuevo con init .
just convex run initPara borrar todas las bases de datos
Puede borrar todas las tablas con la función de prueba wipeAllTables .
just convex run testing:wipeAllTablesPara pausar la implementación de backend
Puede ir al panel de control de la configuración de implementación para pausar y reactivar la implementación. Esto detendrá todas las funciones, ya sean invocadas desde el cliente, programadas o como un trabajo cron. Considere esto como un último recurso, ya que existen formas más suaves de detenerse arriba. una vez que
Modifique su archivo package.json para agregar la opción --host a su servidor front-end (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/ "
}
}Ejecute el siguiente comando para iniciar Docker Compose:
docker-compose up --buildUna vez completado, puede cerrar la terminal.
En otra terminal, todavía en el directorio aitown , inicie una terminal Docker interactiva:
docker-compose exec ai-town /bin/bashDescargue y descomprima el backend local 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 Verifique que el archivo convex-local-backend esté en el directorio, luego elimine el archivo zip:
rm convex-local-backend-x86_64-unknown-linux-gnu.zipHaga el archivo ejecutable:
chmod +x /usr/src/app/convex-local-backendInicie el servidor backend de Convex:
./convex-local-backend En otra terminal, en el directorio aitown , reinicie:
docker-compose exec ai-town /bin/bash Configure socat con la dirección IP del host:
HOST_IP=YOUR-HOST-IP # Use your host's IP address (not the Docker IP)
socat TCP-LISTEN:11434,fork TCP: $HOST_IP :11434 &Pruebe la conexión:
curl http://localhost:11434/Si dice "Ollama está corriendo", ¡está bien!
Asegúrate de que Convex sepa dónde encontrar a Ollama (para evitar un error misterioso aleatorio...):
just convex env set OLLAMA_HOST http://localhost:11434Actualiza la lista de navegadores:
npx update-browserslist-db@latestLanzar AI Town:
npm run devinicie el contenedor y luego simplemente abra dos terminales en su carpeta AI-town con docker-compose exec ai-town /bin/bash
Inicie el servidor backend de Convex: bash ./convex-local-backend Y en la segunda terminal, simplemente configurando Socat, inicie AI Town.
Primero, necesitas instalar WSL2. Siga esta guía para configurar WSL2 en su máquina Windows. Recomendamos utilizar Ubuntu como su distribución de Linux.
Abra su terminal WSL (Ubuntu) y actualice sus paquetes:
sudo apt update
NVM (Node Version Manager) ayuda a administrar múltiples versiones de Node.js. Instale NVM y Node.js 18 (la versión estable):
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
Se requiere Python para algunas dependencias. Instale Python y Pip:
sudo apt-get install python3 python3-pip
sudo ln -s /usr/bin/python3 /usr/bin/python
Instalar unzip y socat :
sudo apt install unzip socat
Cargo es el administrador de paquetes de Rust. Instalar Rust y Cargo:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env
just con Cargo just se usa para ejecutar comandos. Instálalo con Cargo:
cargo install just
export PATH="$HOME/.cargo/bin:$PATH"
just --version
socat para puentear puertos para OllamaEjecute el siguiente comando para conectar puertos, permitiendo la comunicación entre Convex y Ollama:
socat TCP-LISTEN:11434,fork TCP:$(cat /etc/resolv.conf | grep nameserver | awk '{print $2}'):11434 &
Pruebe si está funcionando:
curl http://127.0.0.1:11434
Si responde OK, se puede acceder a la API de Ollama.
Clona el repositorio de AI Town desde GitHub:
git clone https://github.com/a16z-infra/ai-town.git
cd ai-town
Instale los paquetes npm necesarios:
npm install
Descargue e instale la versión precompilada 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
En una terminal separada, inicie Convex:
./convex-local-backend
Configure el host de Ollama en Convex:
just convex env set OLLAMA_HOST http://localhost:11434
Finalmente, lanza AI Town:
npm run dev
Visita http://localhost:5173 en tu navegador para ver AI Town en acción.
Si necesita reiniciar los servicios:
Asegúrese de que socat se esté ejecutando:
socat TCP-LISTEN:11434,fork TCP:$(cat /etc/resolv.conf | grep servidor de nombres | awk '{print $2}'):11434 &
Lanzar convexo:
./convexo-local-backend
En otra terminal: 3. Inicie AI Town:
npm run dev
NOTA: cada vez que cambie los datos de los caracteres, debe volver a ejecutar just convex run testing:wipeAllTables y luego npm run dev para volver a cargar todo en Convex. Esto se debe a que los datos de caracteres se envían a Convex en la carga inicial. Sin embargo, tenga en cuenta que just convex run testing:wipeAllTables borrarán todos sus datos.
Crea tus propios personajes e historias: todos los personajes e historias, así como sus referencias de hojas de sprites, se almacenan en caracteres.ts. Puedes comenzar cambiando las descripciones de los personajes.
Actualizando hojas de sprites: en data/characters.ts , verás este código:
export const characters = [
{
name : 'f1' ,
textureUrl : '/assets/32x32folk.png' ,
spritesheetData : f1SpritesheetData ,
speed : 0.1 ,
} ,
...
] ; Deberías encontrar una hoja de sprites para tu personaje y definir el movimiento/activos del sprite en el archivo correspondiente (en el ejemplo anterior, f1SpritesheetData se definió en f1.ts)
Actualizar el fondo (entorno): el mapa se carga en convex/init.ts desde data/gentle.js . Para actualizar el mapa, siga estos pasos:
convertMap.js para convertir el JSON a un formato que el motor pueda utilizar. node data/convertMap.js <mapDataPath> <assetPath> <tilesetpxw> <tilesetpxh><mapDataPath> : ruta al archivo JSON en mosaico.<assetPath> : ruta a las imágenes del conjunto de mosaicos.<tilesetpxw> : ancho del conjunto de mosaicos en píxeles.<tilesetpxh> : altura del conjunto de mosaicos en píxeles. Genera converted-map.js que puedes usar como gentle.jsconvex/music.tsconvex/crons.ts modificando el trabajo de generate new background music . Configure convex/util/llm.ts o establezca estas variables env:
just convex env set LLM_API_HOST # url
just convex env set LLM_MODEL # modelLa configuración del modelo de incrustaciones debe cambiarse en el código, ya que es necesario especificar la dimensión de las incrustaciones.
Para Together.ai, visite https://api.together.xyz/settings/api-keys Para OpenAI, visite https://platform.openai.com/account/api-keys
Puede ejecutar su backend Convex en la nube simplemente ejecutando
npx convex dev --until-success --configure Y actualizando los scripts package.json para eliminar just : cambie just convex ... a convex ...
Luego deberá configurar las variables de entorno que tenía localmente en el entorno de la nube con npx convex env set o en el panel: https://dashboard.convex.dev/deployment/settings/environment-variables
Antes de poder ejecutar la aplicación, deberá asegurarse de que las funciones de Convex estén implementadas en su entorno de producción.
npx convex deploy para implementar las funciones convexas en producciónnpx convex run init --prod Si tiene datos existentes que desea borrar, puede ejecutar npx convex run testing:wipeAllTables --prod
Puede volver a agregar la autenticación del empleado con git revert b44a436 . O simplemente mire esa diferencia para ver qué cambió para eliminarla.
Crear una cuenta de cajero
VITE_CLERK_PUBLISHABLE_KEY y CLERK_SECRET_KEY a .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 . Apoyamos el uso de Ollama para generaciones de conversación. Para tenerlo accesible desde la web, puedes utilizar Tunnelmole o Ngrok o similar.
Usando Tunnelmole
Tunnelmole es una herramienta de creación de túneles de código abierto.
Puede instalar Tunnelmole utilizando una de las siguientes opciones:
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 para Windows aquí y colóquelo en algún lugar de su RUTA.Una vez instalado Tunnelmole, ejecute el siguiente comando:
tmole 11434
Tunnelmole debería generar una URL única una vez que ejecute este comando.
Usando Ngrok
Ngrok es una popular herramienta de tunelización de código cerrado.
Una vez que ngrok esté instalado y autenticado, ejecute el siguiente comando:
ngrok http http://localhost:11434
Ngrok debería generar una URL única una vez que ejecute este comando.
Agregar el punto final de Ollama a Convex
just convex env set OLLAMA_HOST # your tunnelmole/ngrok unique url from the previous stepActualizar dominios de Ollama
Ollama tiene una lista de dominios aceptados. Agregue el dominio ngrok para que no rechace el tráfico. consulte ollama.ai para obtener más detalles.
Convex es una plataforma backend alojada con una base de datos incorporada que le permite escribir el esquema de su base de datos y las funciones del servidor en TypeScript. Las consultas de la base de datos del lado del servidor almacenan automáticamente en caché y se suscriben a los datos, lo que impulsa un gancho useQuery en tiempo real en nuestro cliente React. También hay clientes para Python, Rust, ReactNative y Node, así como una API HTTP sencilla.
La base de datos admite documentos de estilo NoSQL con validación de esquemas opcionales, relaciones e índices personalizados (incluidos campos en objetos anidados).
Las funciones del servidor de query y mutation tienen acceso transaccional y de baja latencia a la base de datos y aprovechan nuestro tiempo de ejecución v8 con barreras de determinismo para proporcionar las garantías ACID más sólidas del mercado: coherencia inmediata, aislamiento serializable y resolución automática de conflictos a través de un control optimista de concurrencia de múltiples versiones. (OCC/MVCC).
Las funciones del servidor de action tienen acceso a API externas y permiten otros efectos secundarios y no determinismo en nuestro tiempo de ejecución v8 optimizado o en un tiempo de ejecución node más flexible.
Las funciones se pueden ejecutar en segundo plano mediante programación y trabajos cron.
El desarrollo es primero en la nube, con recargas en caliente para la edición de funciones del servidor a través de la CLI, implementaciones preliminares, integraciones de informes de excepciones y registros. Hay una interfaz de usuario de panel para explorar y editar datos, editar variables de entorno, ver registros, ejecutar funciones del servidor y más. .
Hay funciones integradas para paginación reactiva, almacenamiento de archivos, búsqueda de texto reactiva, búsqueda de vectores, puntos finales https (para webhooks), importación/exportación de instantáneas, importación/exportación de streaming y validación en tiempo de ejecución para argumentos de funciones y datos de bases de datos.
Todo se escala automáticamente y comenzar es gratis.
