Crate aingle_ai 

AIngle AI Integration Layer

This crate provides AI capabilities for AIngle nodes, implementing:

• Ineru: Dual memory system (short-term + long-term) for pattern learning
• Nested Learning: Multi-level optimization for consensus and validation
• Kaneru: Self-modifying nodes with continual learning
• Emergent Capabilities: Predictive validation, adaptive consensus

Architecture

┌─────────────────────────────────────────────────────────────┐
│                    NESTED LEARNING LAYER                    │
│              (Meta-optimization of network)                 │
└─────────────────────────────────────────────────────────────┘
                             │
                             ▼
┌─────────────────────────────────────────────────────────────┐
│                     INERU MEMORY LAYER                      │
│               (Dual memory per node)                        │
│  ┌──────────────────┐    ┌──────────────────┐              │
│  │ SHORT-TERM       │◄──►│ LONG-TERM        │              │
│  │ (Recent txs)     │    │ (Historical)     │              │
│  └──────────────────┘    └──────────────────┘              │
└─────────────────────────────────────────────────────────────┘
                             │
                             ▼
┌─────────────────────────────────────────────────────────────┐
│                    KANERU AGENT LAYER                        │
│            (Self-modifying nodes)                           │
└─────────────────────────────────────────────────────────────┘

Features

• default: Basic functionality with lightweight implementations
• full-ml: Enable full ML capabilities with candle
• iot: Optimized for IoT devices with minimal memory footprint

Example

use aingle_ai::ineru::{IneruMemory, IneruConfig};

// Create Ineru memory system
let config = IneruConfig::default();
let mut memory = IneruMemory::new(config);

// Process transactions
// let result = memory.process(&transaction);

Modules

emergent

Emergent Capabilities

ineru

Ineru Memory Layer

kaneru

Kaneru Agent Layer

nested_learning

Nested Learning Layer

prelude

Prelude module for convenient imports

Structs

AiConfig

Global AI configuration for AIngle nodes

AiTransaction

Transaction type for AI processing

AnomalyResult

Anomaly detection result

Embedding

Embedding representation

MemoryMatch

Memory match result

Pattern

Pattern extracted from transactions

ProcessResult

Result of processing a transaction through Titans memory

ValidationPrediction

Validation prediction result

Enums

AiError

Errors that can occur in AI operations

ConsensusLevel

Consensus level for adaptive consensus

MemorySource

Source of memory match

ResourceCategory

Resource category for auto-reconfiguration

Functions

pattern_id

Generate a pattern ID from bytes

Type Aliases

AiResult

Result type for AI operations

FeatureVector

Feature vector for ML operations

PatternId

Pattern identifier