DeuxExMachina 🤖 Automated Intelligence Project

⚠️ Projeto Descontinuado e Arquivado

Este projeto não está mais em desenvolvimento ativo e foi arquivado em 1 de agosto de 2025. O código e a documentação são mantidos aqui para fins de referência e consulta. Sinta-se à vontade para clonar, aprender com o código ou usá-lo como base para seus próprios projetos, de acordo com a Licença MIT.

📜 Descrição

DeuxExMachina é um projeto ambicioso para criar uma inteligência artificial modular e escalável, com o objetivo de automatizar demandas pessoais e, potencialmente, residenciais. A arquitetura é baseada em uma máquina virtual (VM) gerenciada por Vagrant, onde os diversos "cores" de IA e serviços de suporte rodarão como contêineres Docker, comunicando-se através de um pipeline de processamento e um broker MQTT.

O desenvolvimento e interação com este ambiente serão facilitados por um compartilhamento Samba configurado para uma pasta interna à VM, garantindo um workspace dedicado e isolado.

🎯 Objetivos Principais

• Desenvolver um sistema de IA com múltiplos "cores" especializados que colaboram em um pipeline.
• Automatizar tarefas e demandas através de processamento inteligente.
• Criar um ambiente de desenvolvimento robusto, seguro e monitorado.
• Permitir a fácil adição de novas funcionalidades e "cores" de IA.
• Explorar conceitos de inteligência coletiva e processamento distribuído de informações.
• Eventualmente, integrar com sistemas de automação residencial e IoT.

🛠️ Tecnologias e Ferramentas

• Virtualização: Vagrant com VirtualBox
• Sistema Operacional da VM: Ubuntu 22.04 LTS (Jammy Jellyfish)
• Provisionamento da VM: Scripts Shell (Bash) para instalar:
  • Essenciais do sistema (git, curl, build-essential, etc.)
  • Node.js (v18.x ou configurável via .env) e Python 3 com Pip
  • Docker Engine e Docker Compose Plugin
  • Ferramentas de Monitoramento: htop, Glances, Netdata
  • Segurança: UFW (Firewall) e Fail2Ban
  • Serviço Watchdog para monitoramento da VM
  • Samba para compartilhamento de pasta de desenvolvimento interna à VM.
• Containerização: Docker e Docker Compose (para orquestrar os serviços de IA, MQTT, bancos de dados, etc.)
• Comunicação entre IAs: MQTT (Mosquitto rodando em Docker)
• Linguagens de Desenvolvimento para IA (Planejado): Python, Node.js
• Controle de Versão: Git e GitHub (github.com/deraldinho/DeusExMachina)

🚀 Configurando o Ambiente de Desenvolvimento

1. Pré-requisitos no Computador Host:

   • Vagrant
   • VirtualBox
   • Git
   • (Opcional, mas recomendado) Um cliente Samba para acessar o workspace na VM.

2. Clonar o Repositório (se ainda não o fez):

   git clone [https://github.com/deraldinho/DeusExMachina.git](https://github.com/deraldinho/DeusExMachina.git)
   cd DeusExMachina

3. Configurar Variáveis de Ambiente (Opcional):

   • Copie o arquivo .env.example (se existir) para .env.
   • Edite o arquivo .env para personalizar configurações como memória da VM, CPUs, IPs, e a senha do Samba (SAMBA_PASSWORD).
   • Domínio de Desenvolvimento: Você pode definir um domínio local personalizado (ex: meuprojeto.dev) através da variável VM_DEV_DOMAIN no arquivo .env. Se não for definida, o padrão deusex.io será usado. Isso é útil para acessar seus projetos na VM diretamente do navegador.

4. Iniciar a Máquina Virtual com Vagrant:

   • Use os scripts start_dev.sh (Linux/macOS) ou start_dev.ps1 (Windows) na raiz do projeto:

     # Para Linux/macOS
     ./start_dev.sh
     # Ou para Windows (PowerShell)
     .\start_dev.ps1

   • Alternativamente, diretamente com Vagrant:

     vagrant up

   • Na primeira vez, o Vagrant baixará a box da VM e executará todos os scripts de provisionamento. Isso pode levar alguns minutos.

5. Configurar Senha do Samba:

   • A senha para o usuário vagrant no Samba pode ser definida via a variável SAMBA_PASSWORD no seu arquivo .env.
   • Se SAMBA_PASSWORD for definida no .env, a senha será configurada automaticamente durante o provisionamento.
   • Se SAMBA_PASSWORD não for definida ou estiver vazia no .env, a senha não será configurada automaticamente. Você precisará defini-la manualmente após o provisionamento, acessando a VM via vagrant ssh e executando:

     sudo smbpasswd -a vagrant

     Siga as instruções para definir a senha.

6. Acessar o Workspace de Desenvolvimento via Samba:

   • O script de configuração do Samba compartilhará a pasta /vagrant (que é interna à VM e NÃO sincronizada com o host) com o nome DeusExMachina_VM_Workspace (ou similar, verifique a saída do script Samba).
   • Dentro desta pasta compartilhada, você encontrará (ou criará) a subpasta Projetos.
   • No seu computador host:
     • Windows: Abra o Explorador de Arquivos e digite \\<IP_DA_VM_PRIVADO>\DeusExMachina_VM_Workspace (ex: \\192.168.56.10\DeusExMachina_VM_Workspace).
     • macOS: No Finder, vá em "Ir" > "Conectar ao Servidor..." e digite smb://<IP_DA_VM_PRIVADO>/DeusExMachina_VM_Workspace.
     • Linux: Dependendo do seu ambiente gráfico, use o gerenciador de arquivos para acessar smb://<IP_DA_VM_PRIVADO>/DeusExMachina_VM_Workspace.
     • Use vagrant como nome de usuário e a senha do Samba que você definiu no passo anterior.
   • O IP privado da VM é definido no Vagrantfile (padrão sugerido: 192.168.56.10).

🏗️ Estrutura do Projeto (Planejada)

• Vagrantfile: Define a máquina virtual e o processo de provisionamento.
• .env (opcional, não versionado): Para configurações personalizadas da VM.
• Resourcer/Scripts/: Contém os scripts shell (.sh) para provisionar a VM.
  • essentials.sh: Ferramentas básicas do sistema.
  • time_locale.sh: Configuração de fuso horário e localização.
  • setup_dnsmasq.sh: Configura um servidor DNS local para o desenvolvimento.
  • node_python.sh: Instalação de Node.js e Python.
  • docker_watchdog.sh: Instalação do Docker Engine, Docker Compose e serviço watchdog.
  • monitoring_tools.sh: Instalação de htop, Glances e Netdata.
  • firewall_security.sh: Configuração do Firewalld.
  • setup_samba_dev_share.sh: Configura o compartilhamento Samba interno à VM.
  • health_check.sh: Verifica a saúde dos serviços essenciais da VM.
• start_dev.sh / start_dev.ps1: Scripts para facilitar a inicialização do ambiente Vagrant.
• /home/vagrant/projetos/ (Dentro da VM, acessível via Samba):
  • docker-compose.yml: Definirá os serviços Docker (cores de IA, MQTT, bancos de dados, etc.).
  • ia_core_1/, ia_core_2/, etc.: Diretórios para cada "core" de IA, contendo seus Dockerfile e código-fonte.
  • Outros diretórios de configuração e dados para os serviços Docker.

🗺️ Próximos Passos

1. Finalizar e Testar o Ambiente Vagrant: Garantir que a VM seja provisionada corretamente com todas as ferramentas e o compartilhamento Samba funcione como esperado.
2. Desenvolver o docker-compose.yml:
   • Definir o serviço do broker MQTT (ex: Eclipse Mosquitto).
   • Definir o primeiro "core de IA" (ia_processamento_1) como um serviço Docker simples (ex: Python com Paho-MQTT para se conectar ao broker).
   • Definir outros serviços de suporte (ex: um banco de dados como Redis ou PostgreSQL, se necessário para o primeiro core).
3. Desenvolver o Primeiro Core de IA:
   • Criar o Dockerfile para o ia_processamento_1.
   • Escrever o código básico para que ele se conecte ao MQTT, receba uma mensagem de um tópico de entrada e publique uma mensagem processada em um tópico de saída.
4. Testar o Pipeline Mínimo: Enviar uma mensagem para o tópico de entrada e verificar se o ia_processamento_1 a processa e publica no tópico de saída.
5. Iterar e Expandir: Adicionar os próximos cores de IA (ia_processamento_2, etc., e depois as IAs de filtro/armazenamento) seguindo a arquitetura de pipeline.

🤝 Contribuindo

Este é um projeto pessoal, mas ideias e sugestões são bem-vindas! Sinta-se à vontade para abrir uma Issue no GitHub para discussões.

📄 Licença

Este projeto está licenciado sob a Licença MIT. Veja o arquivo LICENSE para mais detalhes.

---

Este README foi gerado com base nas discussões e configurações do projeto DeuxExMachina.