Tags and Bloom Gating¶

64-Byte Pure Encoding Header (V2)¶

Every cognitive memory record begins with an encoding header. The header is strictly aligned to a full CPU cache line (64 bytes) for optimal sequential scan performance.

graph LR
    subgraph "Engram Record"
        H["Pure Encoding Header (64 Bytes)"] --> V["INT8 / INT4 Quantized Vector (N Bytes)"]
    end
    style H fill:#27ae60,color:white
    style V fill:#2ecc71,color:white

Layout Overview (64 Bytes)¶

For complete field-by-field bitwise descriptions and separation from mutable strength telemetry, see Binary Record Specifications & Synaptic Header.

128-Bit Inline Synaptic Bloom Filter¶

The synaptic_tags field is an expanded 128-bit inline Bloom filter (occupying 16 bytes across synaptic_tags_lo and synaptic_tags_hi). This allows thousands of unique tag strings to be used across the system while individual records carry contextual tags with virtually zero false positives.

flowchart LR
    TAGS["Ingestion Tags:<br/>['architecture', 'database']"] --> HASH["MurmurHash3 (k=4)"]
    HASH --> BLOOM["128-Bit Bloom Filter<br/><i>Offsets 0x18 - 0x27</i>"]
    QUERY["Query Filter:<br/>'architecture'"] --> QHASH["MurmurHash3 (k=4)"]
    QHASH --> TEST{"Bitwise Register Test<br/>(candidate & query == query)"}
    BLOOM --> TEST
    TEST -->|Match| VECTOR["Evaluate Dense Vector Cosine"]
    TEST -->|Mismatch| SKIP["Skip Candidate (0 Latency)"]

False Positive Characteristics¶

Because matching requires only two 64-bit CPU register bitwise AND instructions, non-matching engrams are rejected in under a nanosecond, preserving SIMD vector registers for relevant candidates.

Psychological Memory Modulations¶

1. Zeigarnik Effect (Active Task Accessibility)¶

In psychology, the Zeigarnik Effect describes the phenomenon where unresolved tasks remain more accessible in memory than completed ones. Spector models this in the flags bitfield:

• Unresolved Engram: The memory resists normal temporal decay, keeping active action items and open questions immediately available.
• Resolved Engram: When the task is completed (client.memory.resolve(id)), the flag is toggled and standard time-decay resumes.

2. Arousal-Modulated Retention¶

Emotionally intense experiences resist forgetting. Spector uses an unsigned arousal byte (\(0\) to \(255\)) to modulate the power-law forgetting curve:

• High arousal (e.g. critical production failure, major milestone) slows decay by up to \(1.65\times\).
• Neutral engrams (routine conversational exchanges) decay according to baseline retention curves.
• When omitted, arousal is automatically derived from emotional valence: $\(\text{arousal} = \min(255, |\text{valence}| \times 2)\)$

Power-Law Temporal Decay¶

Rather than computing computationally expensive exponential functions in the hot loop, Spector quantizes time into 12 discrete time buckets spanning seconds to years, evaluating decay according to the power law of forgetting:

Long-Term Potentiation (LTP) Reinforcement¶

Every time a memory is explicitly reinforced by an agent or user (client.memory.reinforce(id)), its perceived age is shifted right along the bucket index. A memory recalled and reinforced 3 times is perceived as \(8\times\) younger than its chronological age, effectively preserving critical operational knowledge indefinitely.

Client SDK Connectivity¶

from spector_client import SpectorClient, MemoryTier

client = SpectorClient.builder().with_rest("http://localhost:7070").build()

# Store with synaptic tags and emotional valence
record = client.memory.remember(
    text="Production database failover drill successful",
    tier=MemoryTier.SEMANTIC,
    tags=["database", "drill", "dr"],
    interest=0.9,
    valence=1,
)

# Reinforce memory via Long-Term Potentiation (LTP)
client.memory.reinforce(record.get('id', 'stored'), valence=1)

import { SpectorClient, MemoryTier } from '@spectrayan/spector-client';

const client = SpectorClient.createDefault('http://localhost:7070');

// Store with synaptic tags and emotional valence
const record = await client.memory.remember({
  text: 'Production database failover drill successful',
  tier: MemoryTier.SEMANTIC,
  tags: ['database', 'drill', 'dr'],
  interest: 0.9,
  valence: 1,
});

// Reinforce memory via Long-Term Potentiation (LTP)
await client.memory.reinforce(record.id as string, 1);

import com.spectrayan.spector.client.SpectorClient;
import java.util.List;

try (var client = SpectorClient.builder().baseUri("http://localhost:7070").build()) {
    // Store with synaptic tags
    var record = client.memory().remember(
        "Production database failover drill successful",
        "SEMANTIC",
        List.of("database", "drill", "dr")
    );

    // Reinforce memory
    client.memory().reinforce(record.getId(), 1);
}

# Store memory
curl -X POST http://localhost:7070/api/v1/memory/remember \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Production database failover drill successful",
    "tier": "SEMANTIC",
    "tags": "database,drill,dr",
    "interest": 0.9,
    "valence": 1
  }'

# Reinforce memory
curl -X POST http://localhost:7070/api/v1/memory/{id}/reinforce \
  -H "Content-Type: application/json" \
  -d '{"boost": 1.0}'

Next Steps¶

• The 6-Phase Scoring Pipeline — hot-loop SIMD scoring
• Memory Kernel Layouts — byte-level layout specifications
• Dopamine — Surprise Detection — Bayesian surprise and flashbulb memories
• Cortex — 4-Tier Memory — 4 cognitive memory tiers