# Overview **Versión:** 1.1 **Estado:** Definición --- ## Visión General Sistema de arquitecturas personales y empresariales. ARCHITECT (con Claude) construye y despliega servidores autónomos (DECK, CORP) que operan independientemente. Los componentes internos son microservicios backend, no IA. Las instancias están diseñadas para **consumir** servicios de IA externos (APIs, RunPod), no para contenerla. --- ## Arquitectura General ``` ┌─────────────────────────────────────────────────────────────┐ │ ARCHITECT │ │ PostgreSQL central │ Gitea │ Orchestrator │ Infisical │ └─────────────────────────────────────────────────────────────┘ │ │ │ ▼ ▼ ▼ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ DECK │ │ CORP │ │ HST │ │ │ │ │ │ │ │ secretaría │ │ secretaría │ │ 973 tags │ │ administración │ │ administración │ │ API pública │ │ contable │ │ contable │ │ │ │ producción │ │ producción │ │ │ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ │ └────────┬───────────┘ ▼ ┌─────────────────────────────────────────────────────────────┐ │ Cloudflare R2 (buckets) │ │ architect │ deck │ corp │ hst │ locker │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Flujo de Datos Principal El sistema tiene dos flujos según el origen y completitud de la información: ### Diagrama General ``` ┌─────────────────────────────────────────────────────────────┐ │ ORÍGENES │ ├─────────────────────────────────────────────────────────────┤ │ │ │ ┌─────────────────┐ ┌─────────────────────────┐ │ │ │ PRODUCCIÓN │ │ ENTRADA MANUAL │ │ │ │ Alfred/Jared │ │ (Packet, API, manual) │ │ │ │ │ │ │ │ │ │ Flujos │ │ Datos incompletos │ │ │ │ predefinidos │ │ o ad-hoc │ │ │ └────────┬────────┘ └────────────┬────────────┘ │ │ │ │ │ │ │ (datos completos) │ │ │ │ │ │ └───────────┼─────────────────────────────────┼──────────────┘ │ │ ▼ ▼ ┌─────────────────────────────────────────────────────────────┐ │ SECRETARÍA │ │ Clara / Margaret │ ├─────────────────────────────────────────────────────────────┤ │ • Punto de entrada ÚNICO │ │ • Log inmutable │ │ • Todo se registra exactamente como llega │ └─────────────────────────────────────────────────────────────┘ │ │ ┌────────┴────────┐ │ │ encaja no encaja │ │ │ ▼ │ ┌─────────────────────────────────────────────────────┐ │ │ ADMINISTRACIÓN │ │ │ Mason │ │ ├─────────────────────────────────────────────────────┤ │ │ • Ventana de enriquecimiento (24h configurable) │ │ │ • Usuario completa/corrige datos │ │ │ • Auto-envío si expira el tiempo │ │ └──────────────────────────┬──────────────────────────┘ │ │ └───────────────┬───────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ CONTABLE │ │ Feldman │ ├─────────────────────────────────────────────────────────────┤ │ • Cola de validación (24h configurable) │ │ • Consolidación en bloques inmutables │ │ • Encadenamiento hash (blockchain-style) │ └─────────────────────────────────────────────────────────────┘ ``` ### Regla de Decisión | Condición | Ruta | Descripción | |-----------|------|-------------| | **Encaja** | Secretaría → Feldman | Datos completos de flujo predefinido | | **No encaja** | Secretaría → Mason → Feldman | Entrada manual o incompleta | ### Flujo de Producción (encaja) Cuando la información viene de un proceso predefinido y está completa: ``` Producción (Alfred/Jared) │ │ flujo predefinido completo ▼ Secretaría (Clara/Margaret) ← Registro inmutable │ │ directo (salta Mason) ▼ Contable (Feldman) ← Consolidación ``` ### Flujo Estándar (no encaja) Cuando la información es manual, ad-hoc o incompleta: ``` Entrada manual (Packet, API, etc.) │ ▼ Secretaría (Clara/Margaret) ← Registro inmutable │ ▼ Administración (Mason) ← Enriquecimiento (24h) │ ▼ Contable (Feldman) ← Consolidación ``` --- ## Auditoría (Sentinel) Sentinel es un **componente independiente** que opera de forma transversal sobre el sistema: ``` ┌─────────────────────────────────────────────────────────────┐ │ SENTINEL │ │ (Auditoría) │ ├─────────────────────────────────────────────────────────────┤ │ │ │ Monitoriza y verifica integridad en múltiples puntos: │ │ │ │ • Secretaría ←── verifica inmutabilidad del log │ │ • Mason ←── verifica ventanas temporales │ │ • Feldman ←── verifica encadenamiento de bloques │ │ │ │ Modos de operación: │ │ • LIGHT: verificación rápida (cada 5 min) │ │ • DEEP: auditoría completa (cada 1h) │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Principio de Diseño ### Constructores, no gestores ARCHITECT (con Claude) es un **constructor de arquitecturas**, no un gestor permanente. - ARCHITECT diseña y construye la arquitectura de cada servidor - Cuando la arquitectura esté madura, el servidor será **clonable e independiente** - DECK y CORP funcionan sin conexión a ARCHITECT ni a Claude - Son sistemas diseñados para **usar** servicios de IA (APIs externas, RunPod), no para contenerla ### Descentralización operativa ``` Architect App (centralizado) → Diseña moldes ↓ Instancias reales (descentralizadas) ↓ Cada una con su CORP, su DECK, sus agentes ``` --- ## Modelo de Instancias **DECK** y **CORP** son plantillas. En producción habrá múltiples instancias: | Tipo | Ejemplos | |------|----------| | **DECK** | "Deck de Juan", "Deck de Victoria" | | **CORP** | "Empresa A SL", "Empresa B Corp" | Cada instancia: - Tiene su propio bucket de almacenamiento - Puede renombrar sus agentes - **Opera de forma autónoma** (no depende de ARCHITECT en runtime) - Tiene su propio gestor de secretos - Hace sus propios backups a R2 --- ## Servicios Compartidos (Opcionales) Las instancias **pueden** conectarse a servicios GPU compartidos: | Servicio | Función | Requerido | |----------|---------|-----------| | Grace | Extracción IA | Opcional | | The Factory | Generación | Opcional | | Circle | Colaboración | Opcional | > **Nota:** Si los servicios compartidos no están disponibles, la instancia sigue operando. Solo las funciones de IA estarán limitadas.