SILVIA Core – ApiMem Reference

Version: 3.1

Namespace: CognitiveCode.Silvia.Api

---

The Modular Knowledge Architecture

The Innovation: Hot-Swappable Expert Brain Domains

Traditional AI: One Massive Model

EVERYTHING in one model:
- Medical knowledge
- Legal knowledge  
- Technical support
- Company policies
- Product catalogs
- Customer service
↓
PROBLEMS:
- Can't update without retraining
- Can't segment by access level
- Can't swap contexts dynamically
- Huge memory footprint
- Slow inference

SILVIA ApiMem: Composable Brain Modules

Base Brain (core_knowledge.slv)
    ↓
+ Medical Domain (medical_expert.slv)     [Merge when needed]
+ Legal Domain (legal_expert.slv)         [Merge when needed]
+ Technical Domain (tech_support.slv)     [Merge when needed]
    ↓
CAPABILITIES:
✓ Load/unload domains at runtime
✓ Merge multiple expert brains
✓ Selective group enable/disable
✓ Tiered access per domain
✓ Minimal memory (only active knowledge)
✓ Fast context switching

---

The Modular Brain System

Core Concept: Build AI Like Lego Bricks

Instead of one giant monolithic brain, SILVIA uses composable knowledge modules:

Enterprise Deployment Example:

core_base.slv                    ← Always loaded (greetings, navigation, errors)
    ├─ company_policies.slv      ← Load for HR interactions
    ├─ product_catalog.slv       ← Load for sales interactions  
    ├─ tech_support.slv          ← Load for support interactions
    ├─ executive_sops.slv        ← Load for C-level users ONLY
    └─ customer_training.slv     ← Load for customer education

RESULT:
- Start with 5MB base brain
- Merge 50MB tech support when needed
- Unload tech, load 20MB product catalog
- Context switches in <1 second
- Total memory: 5MB + current domain (not 100MB everything)

The Four-Layer Architecture:

1. File Layer - .slv brain files (concepts + bindings + behaviors + scripts)
2. Merge Layer - Combine multiple brain files additively
3. Group Layer - Enable/disable behavior groups without deleting
4. Export Layer - Save selective groups back to files

This is the foundation for:

• Multi-tenant expert systems
• Tiered knowledge access
• Domain-specific AI agents
• Modular SOPs
• Hot-swappable contexts

---

Core API Methods

Brain File Operations

Load(string filename, bool merge, bool boot)

Loads or merges SILVIA brain file(s) into memory.

Purpose:

• Fresh Load: Replace current brain entirely (merge = false)
• Additive Merge: Add knowledge to existing brain (merge = true)
• Multi-File: Load multiple brains with pipe separator |
• Auto-Boot: Execute "boot" behavior after load (boot = true)

Usage:

SilviaApiMem mem = Core.ApiMem();

// Fresh load - replace entire brain
bool success = mem.Load("base_knowledge.slv", false, true);

// Merge additional domain knowledge
mem.Load("medical_expert.slv", true, false);

// Merge multiple brains at once
mem.Load("cars.slv|pets.slv|books.slv", true, false);

Parameters:

• filename (string): Path to brain file(s), pipe-separated for multiple
• merge (bool): False = replace brain, True = merge additively
• boot (bool): True = execute "boot" behavior after load

Returns: bool - True if loaded successfully

Merge Behavior:

• Concepts: New concepts added, existing concepts unchanged
• Bindings: New bindings added, duplicate bindings ignored
• Behaviors:
  • If Group+Name match → exuders/absorbers ADDED to existing behavior
  • If Group+Name unique → new behavior created
• Scripts: New scripts added, conflicts resolved by order

Boot Behavior:

// If brain file contains behavior:
// Group: "system"
// Name: "boot"

// And boot = true:
// → "boot" behavior executes immediately after load
// → Use for initialization, setup, logging, etc.

---

Save(string filename, string groups, bool SILVIA2 = false)

Saves current brain to file (full or selective groups).

Purpose:

• Full Save: Save entire brain (groups = "all" or null)
• Selective Save: Save only specific groups (groups = "group1|group2")
• Export Domains: Extract knowledge modules to separate files
• Backward Compat: SILVIA2 format for legacy systems

Usage:

// Save entire brain
mem.Save("complete_brain.slv", "all");

// Save only specific groups
mem.Save("medical_domain.slv", "medical|diagnosis|treatment");

// Save everything except one group (delete first, then save)
mem.GroupDelete("temp_data");
mem.Save("cleaned_brain.slv", "all");

// SILVIA2 format (legacy compatibility)
mem.Save("legacy_brain.slv", "all", true);

Parameters:

• filename (string): Path where brain file will be saved
• groups (string): Pipe-separated group names, "all", or null for everything
• SILVIA2 (bool): True for SILVIA2 format compatibility (default false)

Returns: bool - True if saved successfully

What Gets Saved:

• Concepts: All concepts in selected groups + their bindings
• Behaviors: All behaviors in selected groups (absorbers, exuders, scripts)
• System Variables: $_a (AI name) and other marked system vars
• NOT Saved: Feedback memory, temporary variables, runtime state

Selective Save Strategy:

// Extract domain knowledge to separate files
mem.Save("domains/medical.slv", "medical|diagnosis");
mem.Save("domains/legal.slv", "legal|contracts");
mem.Save("domains/technical.slv", "technical|support");

// Now you have modular domain files for:
// - Separate version control
// - Independent updates
// - Selective deployment
// - Access control

---

MergeText(string files)

Merges SILVIA Expert Text files into brain.

Purpose:

• Human-Readable Format: Author behaviors in plain text (not binary .slv)
• Version Control: Git-friendly text format
• Collaborative Authoring: Easy for non-programmers
• Rapid Prototyping: Quick behavior additions without Studio

Expert Text Format:

//Comment: This is a greeting behavior
[conversation greeting]
@absorber hello
@absorber hi there
@absorber hey *
@reuse
@dynamic
@exuder Hello! How can I help you today?
@exuder Hi there! What can I do for you?

Usage:

// Merge single expert text file
mem.MergeText("experts/greetings.txt");

// Merge multiple expert text files
mem.MergeText("experts/medical.txt|experts/legal.txt");

Parameters:

• files (string): Path(s) to expert text file(s), pipe-separated for multiple

Returns: bool - True if merged successfully

Expert Text Syntax:

// Comment line
^ concept relation bound_concept        // Concept binding
[group subgroup name]                   // Behavior declaration
@absorber pattern text                  // Input pattern
@exuder response text                   // Output pattern

// Absorber flags
@exact          // Require exact match
@reject         // Rejection filter
@prompt         // Mark as LLM prompt
@required 1,0,1 // Required concepts (1=required, 0=optional)

// Exuder flags
@dynamic        // Enable dynamic generation
@reuse          // Available for Markov sampling
@exact          // Output exactly (no variation)

See Also: ConvertBehaviorsToExpertText(), SaveExpertTextFile()

---

MergeAIML(string files)

Merges AIML (AI Markup Language) files into brain.

Purpose:

• Legacy Compatibility: Import classic chatbot data
• AIML Libraries: Leverage existing conversational datasets
• Quick Bootstrapping: Add conversational fallbacks

AIML to SILVIA Mapping:

<!-- AIML -->
<category>
  <pattern>HELLO *</pattern>
  <template>Hi there!</template>
</category>

<!-- Becomes SILVIA Behavior: -->
Group: "aiml"
Name: "hello"
Absorber: "hello *"
Exuder: "Hi there!"

Usage:

// Merge AIML conversational data
mem.MergeAIML("aiml/general.xml");

// Merge multiple AIML files
mem.MergeAIML("aiml/greetings.xml|aiml/smalltalk.xml");

Parameters:

• files (string): Path(s) to AIML file(s), pipe-separated for multiple

Returns: bool - True if merged successfully

Note: AIML is deprecated but supported for backward compatibility

---

Behavior Group Management

Groups are logical containers for organizing behaviors - the foundation of modular knowledge architecture.

GetAllGroups()

Returns all behavior groups in brain.

Usage:

string allGroups = mem.GetAllGroups();
// Returns: "conversation|support|medical|legal|errors"

Returns: string - Pipe-separated list of all groups

---

GetActiveGroups(bool expand)

Returns currently active (enabled) behavior groups.

Purpose:

• Check Active Context: See what knowledge is currently loaded
• Wildcard Expansion: Resolve wildcard patterns to actual groups

Usage:

// Get active groups with wildcards
string active = mem.GetActiveGroups(false);
// Returns: "conversation|support*"

// Expand wildcards to actual groups
string expanded = mem.GetActiveGroups(true);
// Returns: "conversation|support_basic|support_advanced|support_expert"

Parameters:

• expand (bool): True to expand wildcards, false for raw format

Returns: string - Pipe-separated list of active groups

Wildcard Patterns:

• support* → all groups starting with "support"
• *medical → all groups ending with "medical"
• *training* → all groups containing "training"

---

GroupEnable(string groups)

Enables specified behavior groups (additive).

Purpose:

• Activate Knowledge: Turn on behaviors without reloading brain
• Context Switching: Add domain knowledge to current context
• Incremental Loading: Gradually add capabilities

Usage:

// Enable single group
mem.GroupEnable("medical");

// Enable multiple groups (additive)
mem.GroupEnable("medical|diagnosis|treatment");

// Already-enabled groups stay enabled
// Newly specified groups are added to active set

Parameters:

• groups (string): Pipe-separated group names to enable

Returns: bool - True if enabled successfully

Additive Behavior:

// Start state: [conversation] active
mem.GroupEnable("support");
// Result: [conversation, support] active

mem.GroupEnable("medical");
// Result: [conversation, support, medical] active

---

GroupEnableOnly(string groups)

Enables ONLY specified groups, disables all others.

Purpose:

• Exclusive Context: Switch to specific knowledge domain
• Clean Slate: Replace entire active set
• Security: Limit to authorized knowledge only

Usage:

// Disable everything except medical domain
mem.GroupEnableOnly("medical|diagnosis|treatment");

// Switch to customer service context
mem.GroupEnableOnly("conversation|support|products");

// Enable everything
mem.GroupEnableOnly("*");

Parameters:

• groups (string): Pipe-separated group names (only these will be active)

Returns: bool - True if set successfully

Replacement Behavior:

// Current state: [conversation, support, medical] active
mem.GroupEnableOnly("legal");
// Result: [legal] active (all others disabled)

---

GroupDisable(string groups)

Disables specified behavior groups.

Purpose:

• Unload Knowledge: Remove domain from active context
• Memory Optimization: Reduce active behavior count
• Context Restriction: Limit available responses

Usage:

// Disable single group
mem.GroupDisable("temp_test");

// Disable multiple groups
mem.GroupDisable("medical|legal|finance");

Parameters:

• groups (string): Pipe-separated group names to disable

Returns: bool - True if disabled successfully

Subtractive Behavior:

// Current state: [conversation, support, medical, legal] active
mem.GroupDisable("medical|legal");
// Result: [conversation, support] active

---

GroupIsEnabled(string group)

Checks if a specific group is currently enabled.

Usage:

if (mem.GroupIsEnabled("medical")) {
    Console.WriteLine("Medical knowledge is active");
} else {
    Console.WriteLine("Medical knowledge is disabled");
}

Parameters:

• group (string): Group name to check

Returns: bool - True if enabled, false if disabled

---

GroupExists(string group)

Checks if a group exists in the brain (enabled or disabled).

Usage:

if (mem.GroupExists("premium_features")) {
    // Group is in brain (may be disabled)
    mem.GroupEnable("premium_features");
} else {
    // Need to load brain file containing this group
    mem.Load("premium.slv", true, false);
}

Parameters:

• group (string): Group name to check

Returns: bool - True if group exists in brain

---

GroupDelete(string groups)

Permanently deletes behavior groups from memory.

Purpose:

• Remove Knowledge: Delete unwanted behaviors
• Cleanup: Remove test/temporary groups
• Memory Recovery: Free RAM by deleting unused groups

Usage:

// Delete single group
mem.GroupDelete("test_data");

// Delete multiple groups
mem.GroupDelete("temp|debug|old_version");

Parameters:

• groups (string): Pipe-separated group names to delete

Returns: bool - True if deleted successfully

Warning: This is permanent! Deleted groups cannot be recovered unless reloaded from file.

---

GroupSubgroupsDelete(string group, string subgroups)

Deletes specific subgroups within a parent group.

Purpose:

• Fine-Grained Cleanup: Remove specific sub-categories
• Partial Updates: Delete old subgroups before merging new ones

Usage:

// Delete specific subgroups from "medical" group
mem.GroupSubgroupsDelete("medical", "deprecated|old_protocols");

Parameters:

• group (string): Parent group name
• subgroups (string): Pipe-separated subgroup names to delete

Returns: bool - True if deleted successfully

---

GroupDeleteExcept(string groups)

Deletes ALL groups EXCEPT the specified ones.

Purpose:

• Inverse Delete: Keep specific groups, remove everything else
• Context Reset: Start fresh with only core knowledge

Usage:

// Keep only core groups, delete everything else
mem.GroupDeleteExcept("conversation|errors|navigation");

// Remove all domain knowledge, keep base system
mem.GroupDeleteExcept("system|core");

Parameters:

• groups (string): Pipe-separated group names to KEEP (all others deleted)

Returns: bool - True if operation successful

Warning: This deletes everything NOT in the list!

---

Expert Text Conversion

Convert brain data to/from human-readable Expert Text format.

ConvertBehaviorsToExpertText(bool SILVIA2 = false)

Exports all behaviors to Expert Text format string.

Purpose:

• Documentation: Generate human-readable behavior documentation
• Version Control: Export to text for Git tracking
• Sharing: Share knowledge in readable format
• Backup: Text-based backup of brain content

Usage:

// Export all behaviors to Expert Text
string expertText = mem.ConvertBehaviorsToExpertText();

// Save to file
File.WriteAllText("exported_behaviors.txt", expertText);

// SILVIA2 format (legacy)
string legacyText = mem.ConvertBehaviorsToExpertText(true);

Parameters:

• SILVIA2 (bool): True for SILVIA2 format compatibility

Returns: string - Expert Text representation of all behaviors

Output Format:

///SILVIA Expert Text Import Behaviors

//Conversation | Greeting
[conversation greeting]
@absorber hello
@absorber hi *
@dynamic
@reuse
@exuder Hello! How can I help you?
@exuder Hi there! What's up?


//Support | Technical Help
[support tech_help]
@exact
@absorber need help with *
@nodynamic
@exuder I can help with that. What specifically?

---

ConvertConceptsToExpertText()

Exports all concepts and bindings to Expert Text format.

Purpose:

• Ontology Export: Document semantic network
• Knowledge Transfer: Share concept relationships
• Debugging: Visualize concept bindings

Usage:

// Export all concepts with bindings
string conceptsText = mem.ConvertConceptsToExpertText();

// Save to file
File.WriteAllText("exported_concepts.txt", conceptsText);

Returns: string - Expert Text representation of all concepts

Output Format:

//SILVIA Expert Text Import Concepts

^tokyo location japan
^tokyo isa city
^tokyo property megacity
^japan location asia
^japan isa country
^programming isa skill
^programming relatedTo coding
^programming relatedTo software

---

SaveExpertTextFile(string fileName, string path = "")

Saves import behaviors/concepts to Expert Text file.

Purpose:

• Programmatic Export: Save Expert Text from code
• Batch Processing: Generate multiple expert files
• Custom Path: Save to specific location

Usage:

// Prepare import data
mem._importBehaviors.Add(new SilviaImportBehavior(
    "greetings", "", "hello",
    "//Simple greeting behavior"
));

mem._importConcepts.Add(new SilviaImportConcept(
    "hello", "greeting", "isa"
));

// Save to expert text file
bool saved = mem.SaveExpertTextFile("my_knowledge", "C:/exports/");
// Creates: C:/exports/my_knowledge.txt

Parameters:

• fileName (string): Name of file (without extension)
• path (string): Directory path (defaults to desktop if empty)

Returns: bool - True if saved successfully

---

Modular Brain Architecture Patterns

Pattern 1: Tiered Expert System

Build AI with knowledge levels - different brains for different user tiers.

public class TieredExpertSystem {
    private SilviaCore Core;
    private SilviaApiMem mem;
    
    public void LoadKnowledgeForUserLevel(int userLevel) {
        mem = Core.ApiMem();
        
        // Everyone gets base knowledge
        mem.Load("base_knowledge.slv", false, true);
        
        // Tier 1: Basic users
        if (userLevel >= 1) {
            mem.Load("basic_features.slv", true, false);
            mem.GroupEnable("help|faq|navigation");
        }
        
        // Tier 2: Premium users
        if (userLevel >= 2) {
            mem.Load("premium_features.slv", true, false);
            mem.GroupEnable("advanced_help|tutorials|insights");
        }
        
        // Tier 3: Enterprise users
        if (userLevel >= 3) {
            mem.Load("enterprise_features.slv", true, false);
            mem.GroupEnable("api_docs|admin|analytics");
        }
        
        // Tier 4: Developers/Partners
        if (userLevel >= 4) {
            mem.Load("developer_docs.slv", true, false);
            mem.GroupEnable("sdk|api_reference|integration_guides");
        }
        
        // Tier 5: Internal/Executives
        if (userLevel >= 5) {
            mem.Load("internal_sops.slv", true, false);
            mem.Load("executive_reports.slv", true, false);
            mem.GroupEnable("company_policies|financials|roadmap");
        }
    }
}

// Usage:
var system = new TieredExpertSystem();
system.LoadKnowledgeForUserLevel(3); // Enterprise user

// Result: Only knowledge appropriate for level 3 is loaded
// - No access to internal SOPs
// - No developer documentation clutter
// - Focused, relevant knowledge only

---

Pattern 2: Dynamic Domain Swapping

Hot-swap expert domains based on conversation context.

public class DynamicDomainSwitcher {
    private SilviaCore Core;
    private SilviaApiMem mem;
    private string currentDomain = "";
    
    public void SwitchDomain(string newDomain) {
        if (currentDomain == newDomain) return;
        
        mem = Core.ApiMem();
        
        // Unload current domain (keep base)
        if (!string.IsNullOrEmpty(currentDomain)) {
            mem.GroupDisable(currentDomain + "*");
        }
        
        // Load and enable new domain
        switch (newDomain.ToLower()) {
            case "medical":
                if (!mem.GroupExists("medical_diagnosis")) {
                    mem.Load("domains/medical.slv", true, false);
                }
                mem.GroupEnable("medical*");
                break;
                
            case "legal":
                if (!mem.GroupExists("legal_contracts")) {
                    mem.Load("domains/legal.slv", true, false);
                }
                mem.GroupEnable("legal*");
                break;
                
            case "technical":
                if (!mem.GroupExists("tech_support")) {
                    mem.Load("domains/technical.slv", true, false);
                }
                mem.GroupEnable("tech*");
                break;
                
            case "financial":
                if (!mem.GroupExists("finance_analysis")) {
                    mem.Load("domains/financial.slv", true, false);
                }
                mem.GroupEnable("finance*");
                break;
        }
        
        currentDomain = newDomain;
        Console.WriteLine($"Switched to {newDomain} domain");
    }
    
    public void DetectAndSwitch(string userInput) {
        // Auto-detect domain from keywords
        if (userInput.Contains("diagnosis") || userInput.Contains("symptoms")) {
            SwitchDomain("medical");
        } else if (userInput.Contains("contract") || userInput.Contains("legal")) {
            SwitchDomain("legal");
        } else if (userInput.Contains("bug") || userInput.Contains("error code")) {
            SwitchDomain("technical");
        } else if (userInput.Contains("investment") || userInput.Contains("portfolio")) {
            SwitchDomain("financial");
        }
    }
}

// Usage:
var switcher = new DynamicDomainSwitcher();

// User asks about medical topic
switcher.DetectAndSwitch("I have flu symptoms");
// → Auto-loads medical brain, disables others

// User asks about legal topic
switcher.DetectAndSwitch("I need a contract review");
// → Auto-loads legal brain, disables medical

---

Pattern 3: Modular SOP System

Build Standard Operating Procedure library with selective access.

public class ModularSOPSystem {
    private SilviaCore Core;
    private SilviaApiMem mem;
    
    public void BuildSOPLibrary() {
        mem = Core.ApiMem();
        
        // Save each department's SOPs to separate files
        SaveDepartmentSOPs("hr", new string[] {
            "onboarding", "offboarding", "benefits", "policies"
        });
        
        SaveDepartmentSOPs("engineering", new string[] {
            "code_review", "deployment", "incident_response", "security"
        });
        
        SaveDepartmentSOPs("sales", new string[] {
            "prospecting", "demo_workflow", "closing", "crm_usage"
        });
        
        SaveDepartmentSOPs("support", new string[] {
            "ticket_triage", "escalation", "customer_comm", "sla_compliance"
        });
    }
    
    private void SaveDepartmentSOPs(string dept, string[] sopGroups) {
        // Save only this department's groups
        string groupList = string.Join("|", sopGroups.Select(s => $"{dept}_{s}"));
        mem.Save($"sops/{dept}_procedures.slv", groupList);
        
        Console.WriteLine($"Saved {dept} SOPs: {groupList}");
    }
    
    public void LoadSOPsForEmployee(string department, string role) {
        mem = Core.ApiMem();
        
        // Load base SOPs (everyone)
        mem.Load("sops/company_basics.slv", false, true);
        
        // Load department-specific SOPs
        mem.Load($"sops/{department}_procedures.slv", true, false);
        mem.GroupEnable($"{department}*");
        
        // Load role-specific SOPs
        if (role == "manager") {
            mem.Load("sops/management_sops.slv", true, false);
            mem.GroupEnable("management*|reporting*");
        }
        
        if (role == "executive") {
            mem.Load("sops/executive_sops.slv", true, false);
            mem.GroupEnable("executive*|strategy*|board*");
        }
        
        Console.WriteLine($"Loaded SOPs for {role} in {department}");
    }
}

// Usage:
var sops = new ModularSOPSystem();

// Build separate SOP files per department
sops.BuildSOPLibrary();

// Load SOPs for specific employee
sops.LoadSOPsForEmployee("engineering", "manager");
// → Gets: company basics + engineering SOPs + management SOPs

sops.LoadSOPsForEmployee("sales", "employee");
// → Gets: company basics + sales SOPs (no management access)

---

Pattern 4: Multi-Product Knowledge Base

Manage separate product documentation with on-demand loading.

public class MultiProductKnowledgeBase {
    private SilviaCore Core;
    private SilviaApiMem mem;
    private List<string> loadedProducts = new List<string>();
    
    public void LoadProductKnowledge(string productId) {
        mem = Core.ApiMem();
        
        // Check if already loaded
        if (loadedProducts.Contains(productId)) {
            mem.GroupEnable($"product_{productId}*");
            return;
        }
        
        // Load product brain
        string brainFile = $"products/product_{productId}.slv";
        if (File.Exists(brainFile)) {
            mem.Load(brainFile, true, false);
            loadedProducts.Add(productId);
            Console.WriteLine($"Loaded knowledge for product {productId}");
        }
    }
    
    public void UnloadProductKnowledge(string productId) {
        mem = Core.ApiMem();
        mem.GroupDisable($"product_{productId}*");
        Console.WriteLine($"Unloaded knowledge for product {productId}");
    }
    
    public void AnswerProductQuestion(string productId, string question) {
        // Ensure correct product knowledge is active
        LoadProductKnowledge(productId);
        
        // Disable other products for focused context
        foreach (string otherProduct in loadedProducts) {
            if (otherProduct != productId) {
                mem.GroupDisable($"product_{otherProduct}*");
            }
        }
        
        // Get response with only this product's knowledge
        string[] response = Core.ApiBrain().GetResponseManaged(question);
        
        if (response != null) {
            Console.WriteLine($"[Product {productId}] {response[0]}");
        }
    }
}

// Usage:
var kb = new MultiProductKnowledgeBase();

// Customer asks about Product A
kb.AnswerProductQuestion("A", "How do I configure the settings?");
// → Loads Product A brain, disables others, responds with A-specific answer

// Customer switches to Product B
kb.AnswerProductQuestion("B", "What's the pricing?");
// → Disables Product A, loads Product B, responds with B-specific answer

// Memory efficient: Only active product brain enabled at once

---

Pattern 5: Incremental Knowledge Loading

Progressive enhancement - load knowledge as conversation deepens.

public class IncrementalKnowledgeLoader {
    private SilviaCore Core;
    private SilviaApiMem mem;
    private int conversationDepth = 0;
    
    public void InitializeConversation() {
        mem = Core.ApiMem();
        
        // Level 0: Only basic conversational skills
        mem.Load("level_0_basic.slv", false, true);
        mem.GroupEnableOnly("greetings|navigation|errors");
        conversationDepth = 0;
    }
    
    public void ProcessUserInput(string input) {
        // Analyze input complexity
        int requiredDepth = AnalyzeRequiredDepth(input);
        
        // Load more knowledge if needed
        while (conversationDepth < requiredDepth) {
            conversationDepth++;
            LoadLevel(conversationDepth);
        }
        
        // Get response with current knowledge level
        string[] response = Core.ApiBrain().GetResponseManaged(input);
        // ... process response
    }
    
    private int AnalyzeRequiredDepth(string input) {
        // Simple heuristic: word count + technical terms
        int wordCount = input.Split(' ').Length;
        int techTerms = CountTechnicalTerms(input);
        
        if (wordCount < 5 && techTerms == 0) return 0; // Basic
        if (wordCount < 15 && techTerms < 3) return 1; // Intermediate
        if (wordCount < 30 && techTerms < 5) return 2; // Advanced
        return 3; // Expert
    }
    
    private void LoadLevel(int level) {
        switch (level) {
            case 1:
                // Intermediate knowledge
                mem.Load("level_1_intermediate.slv", true, false);
                mem.GroupEnable("help|tutorials|faq");
                Console.WriteLine("Loaded intermediate knowledge");
                break;
                
            case 2:
                // Advanced knowledge
                mem.Load("level_2_advanced.slv", true, false);
                mem.GroupEnable("technical|apis|integration");
                Console.WriteLine("Loaded advanced knowledge");
                break;
                
            case 3:
                // Expert knowledge
                mem.Load("level_3_expert.slv", true, false);
                mem.GroupEnable("architecture|optimization|internals");
                Console.WriteLine("Loaded expert knowledge");
                break;
        }
    }
}

// Usage:
var loader = new IncrementalKnowledgeLoader();
loader.InitializeConversation(); // Start with minimal knowledge

loader.ProcessUserInput("Hi"); 
// → Level 0 (basic greetings)

loader.ProcessUserInput("How do I configure the API?");
// → Detects complexity, loads Level 1 & 2

loader.ProcessUserInput("Explain the internal architecture of the distributed cache layer");
// → Detects expert-level query, loads Level 3

---

Expert Text Authoring

The SilviaExpertText Helper Class

Programmatic tools for creating Expert Text files.

Import Data Classes:

// Behavior container
SilviaImportBehavior behavior = new SilviaImportBehavior(
    "support",              // group
    "technical",            // subgroup
    "troubleshoot",         // name
    "//Technical support"   // comment
);

// Add absorbers
behavior.absorbers.Add(new SilviaImportAbsorber(
    "I need help with *",   // text
    false,                  // exact
    false,                  // reject
    false,                  // prompt
    null                    // required
));

// Add exuders
behavior.exuders.Add(new SilviaImportExuder(
    "I can help with that. What's the issue?",  // text
    false,                  // exact
    false,                  // dynamic
    true,                   // reuse
    false                   // prompt
));

// Convert to Expert Text
string expertText = SilviaExpertText.ConvertImportBehaviorsToExpertText(
    new List<SilviaImportBehavior> { behavior }
);

Concept binding:

// Create concept with bindings
SilviaImportConcept concept = new SilviaImportConcept(
    "programming",          // concept
    "skill",                // bound concept
    "isa"                   // binding type
);

// Add more bindings
concept.AddBoundConcept("coding", "synonym");
concept.AddBoundConcept("software", "relatedTo");

// Convert to Expert Text
string conceptText = SilviaExpertText.ConvertImportConceptsToExpertText(
    new List<SilviaImportConcept> { concept }
);

Formatting utilities:

// Format text for Expert Text (adds spacing, handles punctuation)
string formatted = SilviaExpertText.FormatForSilviaExpertText(
    "Hello there.How are you?",  // input
    true                          // nonbreaking sentences
);
// Returns: "Hello there ._How are you ?"

// Unformat (remove expert text formatting)
string normal = SilviaExpertText.UnformatFromSilviaExpertText(formatted);
// Returns: "Hello there. How are you?"

// Other utilities
string capitalized = SilviaExpertText.Capitalize1st("hello"); // "Hello"
bool startsVowel = SilviaExpertText.StartingVowel("apple");   // true
string nospaces = SilviaExpertText.Kill_Spaces("hello world"); // "hello_world"
string broken = SilviaExpertText.BreakCamelCase("HelloWorld"); // "Hello World"

---

Advanced Patterns

Pattern 6: Version-Controlled Knowledge

Use Git for brain version control with Expert Text.

public class VersionControlledBrain {
    private SilviaCore Core;
    private SilviaApiMem mem;
    
    public void ExportToGit() {
        mem = Core.ApiMem();
        
        // Export all behaviors to text (Git-friendly)
        string behaviors = mem.ConvertBehaviorsToExpertText();
        File.WriteAllText("knowledge/behaviors.txt", behaviors);
        
        // Export all concepts to text
        string concepts = mem.ConvertConceptsToExpertText();
        File.WriteAllText("knowledge/concepts.txt", concepts);
        
        // Now commit to Git
        // git add knowledge/
        // git commit -m "Update knowledge base"
        // git push
    }
    
    public void ImportFromGit() {
        mem = Core.ApiMem();
        
        // Load base brain
        mem.Load("base.slv", false, true);
        
        // Merge expert text from Git
        mem.MergeText("knowledge/behaviors.txt");
        mem.MergeText("knowledge/concepts.txt");
        
        // Save as binary brain
        mem.Save("compiled_brain.slv", "all");
    }
    
    public void CreateFeatureBranch(string featureName) {
        // Export current state
        ExportToGit();
        
        // Git: create feature branch
        // git checkout -b feature/{featureName}
        
        // Work on new behaviors
        mem._importBehaviors.Add(new SilviaImportBehavior(
            "feature", featureName, "main", 
            $"//Feature: {featureName}"
        ));
        
        // Save feature to separate file
        mem.SaveExpertTextFile($"feature_{featureName}", "knowledge/features/");
        
        // Git: commit feature
        // git add knowledge/features/
        // git commit -m "Add feature: {featureName}"
    }
}

---

Pattern 7: A/B Testing Knowledge Variants

Test different brain versions for performance.

public class ABTestingBrains {
    private SilviaCore CoreA;
    private SilviaCore CoreB;
    
    public void SetupABTest() {
        // Variant A: Current production brain
        CoreA = SilviaCoreManager.CreateCore("A");
        CoreA.ApiMem().Load("production.slv", false, true);
        
        // Variant B: Experimental brain
        CoreB = SilviaCoreManager.CreateCore("B");
        CoreB.ApiMem().Load("production.slv", false, true);
        CoreB.ApiMem().Load("experimental_improvements.slv", true, false);
    }
    
    public string GetResponse(string input, string userId) {
        // Route users to A or B based on ID
        SilviaCore core = (userId.GetHashCode() % 2 == 0) ? CoreA : CoreB;
        
        string[] response = core.ApiBrain().GetResponseManaged(input);
        
        // Log for analysis
        LogABTest(userId, core == CoreA ? "A" : "B", input, response[0]);
        
        return response[0];
    }
    
    public void AnalyzeResults() {
        // Analyze which variant performed better
        // If B wins → promote to production
        CoreB.ApiMem().Save("production_new.slv", "all");
    }
}

---

Best Practices

1. Modular Brain Design

// GOOD: Separate domains into files
base_knowledge.slv              // Core (10MB)
├─ medical_domain.slv          // Medical (50MB)
├─ legal_domain.slv            // Legal (30MB)
└─ technical_domain.slv        // Technical (40MB)

// Load only what's needed
mem.Load("base_knowledge.slv", false, true);
if (topic == "medical") {
    mem.Load("medical_domain.slv", true, false);
}

// BAD: Everything in one file
giant_monolithic_brain.slv     // Everything (130MB)
// Result: Always loads 130MB even if only need 10MB

---

2. Group Naming Conventions

// GOOD: Hierarchical naming with wildcards
"medical_diagnosis_general"
"medical_diagnosis_specialist"
"medical_treatment_basic"
"medical_treatment_advanced"

// Enable all medical
mem.GroupEnable("medical*");

// Enable only diagnosis
mem.GroupEnable("medical_diagnosis*");

// BAD: Flat, inconsistent naming
"diagnosis"
"med_treat"
"medicine_advanced"
// Can't use wildcards effectively

---

3. Selective Saving

// GOOD: Save domains separately
mem.Save("domains/medical.slv", "medical*");
mem.Save("domains/legal.slv", "legal*");
mem.Save("domains/tech.slv", "tech*");

// Update only one domain
mem.Load("domains/medical.slv", true, false);
// ... edit medical behaviors
mem.Save("domains/medical.slv", "medical*");

// BAD: Always save everything
mem.Save("brain.slv", "all");
// Result: Can't update individual domains

---

4. Boot Behaviors

// GOOD: Use boot for initialization
// In brain file, create behavior:
// Group: "system"
// Name: "boot"
// Script (post): Initialize variables, log startup, etc.

mem.Load("brain.slv", false, true); // boot = true
// Automatically runs "boot" behavior

// BAD: Manual initialization after load
mem.Load("brain.slv", false, false);
InitializeManually(); // Forgot this once? System broken

---

5. Expert Text Workflow

// GOOD: Use Expert Text for version control
// 1. Author behaviors in text (human-readable)
File.WriteAllText("behaviors.txt", expertText);

// 2. Version control the text
// git add behaviors.txt
// git commit -m "Add medical behaviors"

// 3. Compile to binary for deployment
mem.MergeText("behaviors.txt");
mem.Save("production.slv", "all");

// BAD: Binary files in Git
// git add brain.slv  // Binary diff = useless

---

See Also

• ApiBrain - Group management affects active behaviors for inference
• ApiCore - Save/load triggers modified flag
• ApiData - Create behaviors programmatically before saving
• ApiUser - Per-user brain persistence

---

© Copyright Cognitive Code Corp. 2007-2026

SILVIA is a registered Trademark of Cognitive Code Corp.