Demonstração ao vivo
Junte-se à nossa comunidade Discord: AI Stack Devs
AI Town é uma cidade virtual onde personagens de IA vivem, conversam e socializam.
Este projeto é um kit inicial implantável para construir e personalizar facilmente sua própria versão da cidade de IA. Inspirado no artigo de pesquisa Agentes Geradores: Simulacros Interativos do Comportamento Humano .
O objetivo principal deste projeto, além de ser muito divertido de trabalhar, é fornecer uma plataforma com uma base sólida que deve ser ampliada. O back-end suporta nativamente estado global compartilhado, transações e um mecanismo de simulação e deve ser adequado para tudo, desde um projeto simples para brincar até um jogo escalonável para vários jogadores. Um objetivo secundário é disponibilizar uma estrutura JS/TS, já que a maioria dos simuladores neste espaço (incluindo o artigo original acima) são escritos em Python.
llama3 e embeddings com mxbai-embed-large .Nota : Existe uma instalação com um clique de um fork deste projeto no Pinokio para qualquer pessoa interessada em executá-lo, mas não em modificá-lo?
git clone https://github.com/a16z-infra/ai-town.git
cd ai-town
npm installBaixe um binário pré-construído (recomendado) ou construa-o a partir do código-fonte e execute-o.
# 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 Isso também instala just (por exemplo, brew install just ou cargo install just ). Usamos just como make para adicionar parâmetros extras, então você executa just convex ... em vez de npx convex ... para desenvolvimento local.
Se você estiver executando o binário pré-construído no Mac e houver um aviso da Apple, vá para a pasta em que ele está, clique com o botão direito e selecione "Abrir" para ignorar. A partir daí você pode executá-lo na linha de comando. Ou você pode compilá-lo a partir do código-fonte e executá-lo (veja acima).
Você pode deixar o aplicativo em execução ou executar ollama serve . ollama serve irá avisá-lo se o aplicativo já estiver em execução. Execute ollama pull llama3 para fazer o download llama3 . Teste com ollama run llama3 . Se você deseja personalizar qual modelo usar, ajuste convex/util/llm.ts ou defina just convex env set LLM_MODEL # model . As opções de modelo Ollama podem ser encontradas aqui.
Você pode querer definir NUM_MEMORIES_TO_SEARCH como 1 em constantes.ts, para reduzir o tamanho dos prompts de conversa, se notar lentidão.
Confira convex/config.ts para configurar quais modelos oferecer à UI ou para configurá-lo para se comunicar com um LLM hospedado na nuvem.
Para geração diária de música de fundo, crie uma conta Replicate e crie um token na página API Token do seu perfil. just convex env set REPLICATE_API_TOKEN # token
Para executar o front e o back-end:
npm run dev Nota : Se você encontrar um erro de versão do nó no servidor convexo na inicialização do aplicativo, use a versão 18 do nó, que é a mais estável. Uma maneira de fazer isso é instalar o nvm e executar nvm install 18 ou nvm use 18 . Faça isso antes do npm run dev acima e do ./convex-local-backend na Etapa 2.
Agora você pode visitar http://localhost:5173.
Se preferir executar o frontend em um terminal separado do Convex (que sincroniza suas funções de backend à medida que são salvas), você pode executar estes dois comandos:
npm run dev:frontend
npm run dev:backend Consulte package.json para obter detalhes, mas dev:backend executa just convex dev
Nota : A simulação irá pausar após 5 minutos se a janela estiver ociosa. Carregar a página a retomará. Você também pode congelar e descongelar manualmente o mundo com um botão na IU. Se você quiser rodar o mundo sem o navegador, você pode comentar o cron "parar mundos inativos" em convex/crons.ts .
Para parar o back-end, em caso de muita atividade
Isso interromperá a operação do mecanismo e dos agentes. Você ainda pode executar consultas e funções para depurar.
just convex run testing:stopPara reiniciar o back-end após interrompê-lo
just convex run testing:resumePara ligar o motor caso o motor do jogo ou os agentes não estejam funcionando
just convex run testing:kickPara arquivar o mundo
Se quiser redefinir o mundo e começar do zero, você pode arquivar o mundo atual:
just convex run testing:archiveEntão, você ainda poderá visualizar os dados mundiais no painel, mas o mecanismo e os agentes não funcionarão mais.
Você pode então criar um novo mundo com init .
just convex run initPara limpar todos os bancos de dados
Você pode limpar todas as tabelas com a função de teste wipeAllTables .
just convex run testing:wipeAllTablesPara pausar sua implantação de back-end
Você pode acessar o painel para acessar as configurações de implantação para pausar e retomar sua implantação. Isso interromperá todas as funções, sejam elas invocadas pelo cliente, agendadas ou como um cron job. Veja isso como último recurso, pois existem maneiras mais suaves de parar acima. Uma vez que você
Modifique seu arquivo package.json para adicionar a opção --host ao seu 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/ "
}
}Execute o seguinte comando para iniciar o Docker Compose:
docker-compose up --buildDepois de concluído, você pode fechar o terminal.
Em outro terminal, ainda no diretório aitown , inicie um terminal Docker interativo:
docker-compose exec ai-town /bin/bashBaixe e descompacte o 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 Verifique se o arquivo convex-local-backend está no diretório e remova o arquivo zip:
rm convex-local-backend-x86_64-unknown-linux-gnu.zipTorne o arquivo executável:
chmod +x /usr/src/app/convex-local-backendInicie o servidor back-end Convexo:
./convex-local-backend Em outro terminal, no diretório aitown , reinicie:
docker-compose exec ai-town /bin/bash Configure socat com o endereço IP do 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 &Teste a conexão:
curl http://localhost:11434/Se disser “Ollama está correndo”, está bom!
Certifique-se de que Convex saiba onde encontrar Ollama (para pular um bug misterioso aleatório...):
just convex env set OLLAMA_HOST http://localhost:11434Atualize a lista do navegador:
npx update-browserslist-db@latestInicie a cidade de IA:
npm run devinicie o contêiner e simplesmente abra dois terminais em sua pasta AI-town com docker-compose exec ai-town /bin/bash
Inicie o servidor backend Convex: bash ./convex-local-backend E no segundo terminal simplesmente configurando o Socat, inicie o AI Town.
Primeiro, você precisa instalar o WSL2. Siga este guia para configurar o WSL2 em sua máquina Windows. Recomendamos usar o Ubuntu como sua distribuição Linux.
Abra seu terminal WSL (Ubuntu) e atualize seus pacotes:
sudo apt update
NVM (Node Version Manager) ajuda a gerenciar várias versões do Node.js. Instale NVM e Node.js 18 (a versão estável):
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 é necessário para algumas dependências. Instale Python e Pip:
sudo apt-get install python3 python3-pip
sudo ln -s /usr/bin/python3 /usr/bin/python
Instale unzip e socat :
sudo apt install unzip socat
Cargo é o gerenciador de pacotes Rust. Instale Rust e Cargo:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env
just com Cargo just é usado para executar comandos. Instale-o com Cargo:
cargo install just
export PATH="$HOME/.cargo/bin:$PATH"
just --version
socat para portas de ponte para OllamaExecute o seguinte comando para conectar as portas, permitindo a comunicação entre Convex e Ollama:
socat TCP-LISTEN:11434,fork TCP:$(cat /etc/resolv.conf | grep nameserver | awk '{print $2}'):11434 &
Teste se está funcionando:
curl http://127.0.0.1:11434
Se responder OK, a API Ollama está acessível.
Clone o repositório AI Town do GitHub:
git clone https://github.com/a16z-infra/ai-town.git
cd ai-town
Instale os pacotes npm necessários:
npm install
Baixe e instale a versão pré-compilada do 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
Em um terminal separado, inicie o Convex:
./convex-local-backend
Defina o host Ollama como Convexo:
just convex env set OLLAMA_HOST http://localhost:11434
Finalmente, inicie o AI Town:
npm run dev
Visite http://localhost:5173 em seu navegador para ver AI Town em ação.
Se você precisar reiniciar os serviços:
Certifique-se de que socat esteja em execução:
socat TCP-LISTEN:11434,fork TCP:$(cat /etc/resolv.conf | grep nameserver | awk '{print $2}'):11434 &
Lançar Convexo:
./convexo-local-backend
Em outro terminal: 3. Inicie o AI Town:
npm run dev
NOTA: toda vez que você alterar os dados do personagem, você deve executar novamente just convex run testing:wipeAllTables e então npm run dev para reenviar tudo para Convex. Isso ocorre porque os dados dos caracteres são enviados para o Convex no carregamento inicial. No entanto, tome cuidado, pois just convex run testing:wipeAllTables IRÁ limpar todos os seus dados.
Crie seus próprios personagens e histórias: Todos os personagens e histórias, bem como suas referências de spritesheets, são armazenados em character.ts. Você pode começar alterando as descrições dos personagens.
Atualizando spritesheets: em data/characters.ts , você verá este código:
export const characters = [
{
name : 'f1' ,
textureUrl : '/assets/32x32folk.png' ,
spritesheetData : f1SpritesheetData ,
speed : 0.1 ,
} ,
...
] ; Você deve encontrar uma planilha de sprite para seu personagem e definir movimentos/ativos de sprite no arquivo correspondente (no exemplo acima, f1SpritesheetData foi definido em f1.ts)
Atualize o plano de fundo (ambiente): O mapa é carregado em convex/init.ts de data/gentle.js . Para atualizar o mapa, siga estas etapas:
convertMap.js para converter o JSON em um formato que o mecanismo possa usar. node data/convertMap.js <mapDataPath> <assetPath> <tilesetpxw> <tilesetpxh><mapDataPath> : caminho para o arquivo JSON lado a lado.<assetPath> : Caminho para imagens do conjunto de blocos.<tilesetpxw> : largura do conjunto de blocos em pixels.<tilesetpxh> : Altura do conjunto de blocos em pixels. Gera converted-map.js que você pode usar como gentle.jsconvex/music.tsconvex/crons.ts modificando o trabalho generate new background music Configure convex/util/llm.ts ou defina estas variáveis de ambiente:
just convex env set LLM_API_HOST # url
just convex env set LLM_MODEL # modelA configuração do modelo de embeddings precisa ser alterada no código, pois você precisa especificar a dimensão dos embeddings.
Para Together.ai, visite https://api.together.xyz/settings/api-keys Para OpenAI, visite https://platform.openai.com/account/api-keys
Você pode executar seu back-end Convex na nuvem apenas executando
npx convex dev --until-success --configure E atualizando os scripts package.json para remover just : altere just convex ... para convex ...
Em seguida, você precisará definir quaisquer variáveis de ambiente que você tinha localmente no ambiente de nuvem com npx convex env set ou no painel: https://dashboard.convex.dev/deployment/settings/environment-variables
Antes de poder executar o aplicativo, você precisará certificar-se de que as funções Convex estão implantadas em seu ambiente de produção.
npx convex deploy para implantar as funções convexas na produçãonpx convex run init --prod Se você tiver dados existentes que deseja limpar, poderá executar npx convex run testing:wipeAllTables --prod
Você pode adicionar a autenticação do funcionário novamente com git revert b44a436 . Ou apenas observe a diferença para ver o que mudou para removê-lo.
Faça uma conta de funcionário
VITE_CLERK_PUBLISHABLE_KEY e 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 . Apoiamos o uso do Ollama para gerações de conversação. Para acessá-lo na web, você pode usar Tunnelmole ou Ngrok ou similar.
Usando Tunnelmole
Tunnelmole é uma ferramenta de tunelamento de código aberto.
Você pode instalar o Tunnelmole usando uma das seguintes opções:
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 aqui e coloque-o em algum lugar do seu PATH.Depois que o Tunnelmole estiver instalado, execute o seguinte comando:
tmole 11434
Tunnelmole deve gerar um URL exclusivo depois de executar este comando.
Usando o Ngrok
Ngrok é uma ferramenta popular de tunelamento de código fechado.
Depois que o ngrok estiver instalado e autenticado, execute o seguinte comando:
ngrok http http://localhost:11434
O Ngrok deve gerar um URL exclusivo assim que você executar este comando.
Adicionar ponto final Ollama ao Convexo
just convex env set OLLAMA_HOST # your tunnelmole/ngrok unique url from the previous stepAtualizar domínios Ollama
Ollama tem uma lista de domínios aceitos. Adicione o domínio ngrok para não rejeitar o tráfego. consulte ollama.ai para obter mais detalhes.
Convex é uma plataforma de back-end hospedada com um banco de dados integrado que permite escrever o esquema do banco de dados e as funções do servidor em TypeScript. As consultas de banco de dados do lado do servidor armazenam em cache e assinam automaticamente os dados, alimentando um gancho useQuery em tempo real em nosso cliente React. Também existem clientes para Python, Rust, ReactNative e Node, bem como uma API HTTP simples.
O banco de dados oferece suporte a documentos no estilo NoSQL com validação de esquema opcional, relacionamentos e índices personalizados (inclusive em campos em objetos aninhados).
As funções do servidor de query e mutation têm acesso transacional e de baixa latência ao banco de dados e aproveitam nosso tempo de execução v8 com proteções de determinismo para fornecer as garantias ACID mais fortes do mercado: consistência imediata, isolamento serializável e resolução automática de conflitos por meio de controle de simultaneidade multiversão otimista. (OCC/MVCC).
As funções do servidor action têm acesso a APIs externas e permitem outros efeitos colaterais e não determinismo em nosso tempo de execução v8 otimizado ou em um tempo de execução node mais flexível.
As funções podem ser executadas em segundo plano por meio de agendamento e cron jobs.
O desenvolvimento prioriza a nuvem, com recarregamentos a quente para edição de funções do servidor por meio da CLI, pré-visualização de implantações, integração de registros e relatórios de exceções. Há uma UI de painel para navegar e editar dados, editar variáveis de ambiente, visualizar logs, executar funções de servidor e muito mais .
Existem recursos integrados para paginação reativa, armazenamento de arquivos, pesquisa de texto reativa, pesquisa de vetor, endpoints https (para webhooks), importação/exportação de snapshot, importação/exportação de streaming e validação de tempo de execução para argumentos de função e dados de banco de dados.
Tudo é dimensionado automaticamente e é gratuito para começar.
