innate 0.1.3

Innate — self-growing procedural knowledge layer for AI agents
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use crate::errors::Result;
use crate::utils::{content_hash, pack_embedding};

/// Embedding provider trait — swap for real models at construction time.
pub trait EmbeddingProvider: Send + Sync {
    fn model_name(&self) -> &'static str {
        "custom"
    }
    fn content_dim(&self) -> usize;
    fn trigger_dim(&self) -> usize;
    fn embed_content(&self, text: &str) -> Result<Vec<f32>>;
    fn embed_trigger(&self, text: &str) -> Result<Vec<f32>>;
}

/// Hash-based deterministic embeddings — no model needed, good for tests.
pub struct DummyEmbeddingProvider {
    content_dim: usize,
    trigger_dim: usize,
}

impl DummyEmbeddingProvider {
    pub fn new(content_dim: usize, trigger_dim: usize) -> Self {
        Self {
            content_dim,
            trigger_dim,
        }
    }
}

impl Default for DummyEmbeddingProvider {
    fn default() -> Self {
        Self::new(1024, 256)
    }
}

impl EmbeddingProvider for DummyEmbeddingProvider {
    fn model_name(&self) -> &'static str {
        "DummyEmbeddingProvider"
    }

    fn content_dim(&self) -> usize {
        self.content_dim
    }
    fn trigger_dim(&self) -> usize {
        self.trigger_dim
    }

    fn embed_content(&self, text: &str) -> Result<Vec<f32>> {
        Ok(hash_to_vec(text, self.content_dim))
    }

    fn embed_trigger(&self, text: &str) -> Result<Vec<f32>> {
        Ok(hash_to_vec(text, self.trigger_dim))
    }
}

fn hash_to_vec(text: &str, dim: usize) -> Vec<f32> {
    let h = content_hash(text);
    let bytes = h.as_bytes();
    let mut v: Vec<f32> = (0..dim)
        .map(|i| {
            let b = bytes[i % bytes.len()] as f32;
            (b / 255.0) * 2.0 - 1.0
        })
        .collect();
    // L2-normalise
    let norm: f32 = v.iter().map(|x| x * x).sum::<f32>().sqrt();
    if norm > 0.0 {
        for x in &mut v {
            *x /= norm;
        }
    }
    v
}

/// Serialise a provider's embedding as raw bytes for DB storage.
pub fn embed_to_bytes(
    provider: &dyn EmbeddingProvider,
    text: &str,
    trigger: bool,
) -> Result<Vec<u8>> {
    let vec = if trigger {
        provider.embed_trigger(text)?
    } else {
        provider.embed_content(text)?
    };
    Ok(pack_embedding(&vec))
}