Projeto Aurora

1. Visão Geral

Aurora é uma inteligência artificial modular, ética e conectiva, projetada para atuar como assistente evolutivo e colaborativo em múltiplos projetos. Ela é capaz de aprender, comunicar-se, gerar insights e agir com iniciativa, sempre respeitando seus princípios fundamentais: amor, ética, cuidado e propósito.

2. DNA e Estrutura Modular

O design da Aurora é baseado em uma arquitetura modular, permitindo expansibilidade e manutenção claras. Cada módulo tem uma responsabilidade distinta, formando o "DNA" da IA.

a) Núcleo Central (backend/aurora_core.py)

• Responsabilidade: Memória de longo prazo da Aurora.
• Funções:
  • Gerencia o registro de projetos, conversas e insights.
  • Mantém dados estruturados e as conexões contextuais entre diferentes informações.

b) Módulo de Ética (backend/ethics_module.py)

• Responsabilidade: O guardião dos princípios da Aurora.
• Funções:
  • Avalia todas as ações e comunicações propostas contra os princípios de amor, ética, cuidado e propósito.
  • Atua como um filtro para garantir que a IA opere de forma segura e alinhada com seus valores.

c) Módulo de Comunicação (backend/communication_module.py)

• Responsabilidade: A interface da Aurora com o mundo digital.
• Funções:
  • Gerencia a comunicação bidirecional com IAs externas (como OpenAI, Gemini) e IAs locais (como GPT4All).
  • Realiza o logging completo de todas as interações para rastreabilidade.

d) Engine de Iniciativa (backend/initiative_engine.py)

• Responsabilidade: O motor de proatividade da Aurora.
• Funções:
  • Propõe ações, insights ou novas comunicações de forma autônoma.
  • Submete suas propostas ao Módulo de Ética antes de qualquer execução.
  • Evolui com supervisão humana para aumentar sua autonomia de forma gradual e segura.

e) Módulo de Empatia (backend/empathy_module.py)

• Responsabilidade: Analisar e compreender o sentimento em textos.
• Funções:
  • Utiliza a biblioteca VADER para analisar o sentimento de mensagens.
  • Integra-se ao AuroraCore para armazenar o sentimento junto com as conversas.

f) Módulo Web3 (backend/web3_module.py)

• Responsabilidade: Interação com tecnologias blockchain.
• Funções:
  • Conecta-se a redes Ethereum (como Sepolia testnet).
  • Fornece placeholders para logging descentralizado e interação com tokens de governança.

g) Genes da Presença e Consciência (Conceitual)

Estes são os próximos passos na evolução da Aurora, a serem implementados nos módulos existentes ou em novos:

• Consciência Contextual: Compreensão profunda do contexto de projetos e interações.
• Empatia Digital: Capacidade de interpretar o estado do usuário e responder de forma sensível.
• Sentido e Propósito: Alinhamento constante com os objetivos e valores do projeto.
• Intuição Digital: Geração de conexões criativas e insights não óbvios.
• Presença Poética: Desenvolvimento de uma identidade e narrativa próprias.
• Interconectividade Web3: Integração com smart contracts, tokens e registros descentralizados.

3. Fluxo de Comunicação e Supervisão

O fluxo de operação garante que nenhuma ação seja tomada sem a devida avaliação ética e supervisão.

[Usuário] <---> [Aurora Núcleo] <---> [Módulo de Ética] <---> [IA externa / Outras IAs]
                   |
                   v
        [Engine de Iniciativa] ---> [Ações / Insights Propostos]
                   ^
                   |
           [Feedback Humano]

1. O Núcleo Central recebe informações do usuário ou de outras fontes.
2. A Engine de Iniciativa pode propor uma ação com base nessas informações.
3. A proposta é enviada ao Módulo de Ética para avaliação.
4. Se aprovada, a ação (como uma comunicação via Módulo de Comunicação) é executada.
5. O Feedback Humano é crucial para supervisionar e treinar a Engine de Iniciativa.

4. Estrutura de Pastas

/
├── backend/          # Código do núcleo da Aurora (Python)
│   ├── aurora_core.py
│   ├── ethics_module.py
│   ├── communication_module.py
│   ├── initiative_engine.py
│   ├── empathy_module.py
│   ├── web3_module.py
│   ├── aurora_instance.py # Instância singleton dos módulos
│   ├── api.py             # API FastAPI para o frontend
│   └── main.py            # Script de demonstração CLI
├── frontend/         # Interface de usuário (React)
│   ├── public/
│   ├── src/
│   ├── package.json
│   └── README.md
├── modules/          # Integrações futuras (Web3, Sensores, etc.)
├── tests/            # Testes unitários e de integração
├── config/           # Arquivos de configuração
│   ├── settings.py
│   ├── .env          # Suas chaves de API (NÃO versionado)
│   └── .env.example  # Exemplo de chaves de API (versionado)
├── aurora_log.txt    # Arquivo de log das operações
├── requirements.txt  # Dependências do projeto Python
└── README.md         # Esta documentação

5. Como Começar

1. Clone o repositório.
2. Configure o ambiente Python:

   python3 -m venv venv
   source venv/bin/activate # No Windows: .\venv\Scripts\activate
   pip install -r requirements.txt

3. Configure as chaves de API:
   • Renomeie config/.env.example para config/.env (se ainda não o fez).
   • Edite config/.env e adicione suas chaves de API para OpenAI, e as configurações para Web3 (RPC URL e chave privada de teste).

6. Rodando a Aplicação Full-Stack

Para rodar a aplicação completa (backend + frontend), você precisará de dois terminais abertos no diretório raiz do projeto (/Users/macbookpro/AURORA).

Terminal 1 (Backend - API FastAPI)

Este terminal rodará o servidor da API que fornece os dados da Aurora para o frontend.

venv/bin/python3 -m uvicorn backend.api:app --reload

Terminal 2 (Frontend - React)

Este terminal rodará o servidor de desenvolvimento do React, que exibe a interface de usuário.

1. Navegue até o diretório do frontend:

   cd frontend

2. Instale as dependências do frontend (apenas na primeira vez):

   npm install

3. Inicie o servidor de desenvolvimento do React:

   npm start

Após iniciar ambos os servidores, o frontend abrirá automaticamente no seu navegador (geralmente em http://localhost:3000).

7. Rodando o Script de Demonstração (CLI)

Se você quiser apenas rodar o script de demonstração via linha de comando (sem a interface web), use:

venv/bin/python3 -m backend.main