Appearance

SILVIA Core – ApiUser Reference ​

Version: 3.1

Namespace: CognitiveCode.Silvia.Api

Multi-User Management & Scalability With SILVIA ​

Single-Core Single-User ​

Single SilviaCore
└── User Session

Fully-Siloed Brain, no instancing or shared knowledgebase.

Single-Core Multi-User ​

Single SilviaCore
├── Shared Brain (1 instance)
└── UserManager
    ├── User "alice"    (variables, history, state)
    ├── User "bob"      (variables, history, state)
    ├── User "charlie"  (variables, history, state)
    └── ...
        └── User 10,000 (isolated data per user)

1 SILVIA Core can track thousands of users with isolated per-user data.

Hybrid Server Model ​

SilviaServer (10,000 cores)
    ├── Core 1 → 10,000 users per core
    ├── Core 2 → 10,000 users per core
    └── Core 10,000 → 10,000 users per core
        = 100,000,000 total users

Combine multi-instancing with per-Core user management for 100M+ user capacity.

Key Innovation: Optional Activation ​

User management is opt-in and zero-impact when disabled:

csharp
// Traditional mode (1 core = 1 user)
var core = SilviaCoreManager.CreateCore("user_alice", "brain.sil", true);
string response = core.ApiBrain().GetResponse(input, null);

// NEW 3.1: Enable internal multi-user tracking
SilviaUserAPI.Enable(core, 10000); // Support up to 10K users

// Now the same core handles multiple users
var alice = SilviaUserAPI.GetUser("alice");
alice.SetUserVariable("$name", "Alice");

var bob = SilviaUserAPI.GetUser("bob");
bob.SetUserVariable("$name", "Bob");

// Each user has isolated data, shared brain knowledge

Table of Contents ​

  1. Overview
  2. Architecture
  3. Quick Start
  4. SilviaUserAPI (Static Interface)
  5. SilviaUserManager
  6. SilviaUser
  7. User Variables
  8. Conversation History
  9. Feedback Management
  10. Memory & State Integration
  11. Session Management
  12. Persistence & Backup
  13. Resource Management
  14. Statistics & Monitoring
  15. Platform-Specific Integrations
  16. Best Practices

Overview ​

ApiUser provides enterprise-grade multi-user session management for SILVIA Core. It enables:

  • Per-User Data Isolation: Variables, conversations, feedback, memory
  • Massive Scalability: 10,000+ users per core
  • Zero Core Impact: Optional activation, no performance penalty when disabled
  • Thread-Safe Operations: Concurrent user access with lock-based safety
  • Comprehensive Persistence: Save/load user data, automatic backups
  • Resource Monitoring: Track memory, activity, health status

What Problems Does This Solve? ​

1. Memory Efficiency ​

Before 3.1: 10K users × 500MB brain = 5TB memory
With 3.1: 1 brain (500MB) + 10K user sessions (50MB) = 550MB memory

2. Hot-Reload Knowledge ​

Before: Update brain → restart 10K cores
With 3.1: Update brain once → all 10K users instantly see changes

3. Per-User Personalization ​

Before: Separate brain files per user
With 3.1: Shared knowledge + per-user variables

4. Enterprise Multi-Tenancy ​

Before: Complex load balancing across cores
With 3.1: Single core handles entire tenant

Architecture ​

Component Hierarchy ​

SilviaUserAPI (Static)
    ↓
SilviaUserManager (Lifecycle)
    ↓
SilviaUser (Data Container)
    ├── Variables (Key/Value)
    ├── Conversations (Input/Output/BehaviorID)
    ├── Feedback (Learning)
    ├── Memory (SilviaMemory)
    └── State (SilviaState)

Data Isolation Model ​

Each SilviaUser contains:

  • Variables: List<Tuple<string, string>> – Per-user settings
  • Conversations: List<Tuple<string, string, int, DateTime>> – Full history
  • Feedback: List<Tuple<string, string, DateTime>> – Learning data
  • Memory: SilviaMemory – Concept snapshots (future integration)
  • State: SilviaState – Event queues (future integration)

Thread Safety: All collections use lock() for concurrent access.

Quick Start ​

Basic Multi-User Setup ​

csharp
// 1. Create a core
var core = SilviaCoreManager.CreateCore("multi_user_core", "chatbot.sil", true);

// 2. Enable user management
SilviaUserAPI.Enable(core, 10000); // Max 10K users

// 3. Handle user requests
void HandleUserRequest(string userId, string input) {
    // Get or create user
    var user = SilviaUserAPI.GetUser(userId);
    
    // Set user-specific context
    user.SetUserVariable("$user_id", userId);
    user.SetUserVariable("$last_input", input);
    
    // Get AI response (shared brain)
    string response = core.ApiBrain().GetResponse(input, null);
    
    // Store conversation
    int behaviorId = core.ApiBrain().GetResponseBehaviorID(0);
    user.AddConversation(input, response, behaviorId);
    
    // Update activity
    SilviaUserAPI.TouchUser(userId);
    
    return response;
}

// Example usage
string response1 = HandleUserRequest("alice", "What's the weather?");
string response2 = HandleUserRequest("bob", "Tell me a joke");
string response3 = HandleUserRequest("alice", "And tomorrow?"); 
// Alice's context is preserved!

Advanced: Per-User Variables in Responses ​

csharp
// Enable user management
SilviaUserAPI.Enable(core);

// User "alice" sets preferences
var alice = SilviaUserAPI.GetUser("alice");
alice.SetUserVariable("$user_name", "Alice");
alice.SetUserVariable("$user_city", "San Francisco");
alice.SetUserVariable("$user_timezone", "PST");

// In SILVIA brain, use variables:
// Behavior: "greetings"
// Exuder: "Hello $user_name from $user_city!"

// When alice asks:
string response = core.ApiBrain().GetResponse("Hello", null);
// Response: "Hello Alice from San Francisco!"

// User "bob" gets different response:
var bob = SilviaUserAPI.GetUser("bob");
bob.SetUserVariable("$user_name", "Bob");
bob.SetUserVariable("$user_city", "New York");

string response2 = core.ApiBrain().GetResponse("Hello", null);
// Response: "Hello Bob from New York!"

SilviaUserAPI (Static Interface) ​

Simple on/off control for the entire user management system.

Enable ​

Activates user management system.

csharp
public static void Enable(SilviaCore core = null, uint maxUsers = 10000)

Parameters:

  • core – Optional SilviaCore reference for future integration
  • maxUsers – Maximum number of concurrent users (default 10,000)

Example:

csharp
// Basic activation
SilviaUserAPI.Enable(core);

// Custom user limit
SilviaUserAPI.Enable(core, 50000); // Support 50K users

Disable ​

Deactivates user management.

csharp
public static void Disable()

Example:

csharp
// Disable user tracking
SilviaUserAPI.Disable();

// User API calls now return null
var user = SilviaUserAPI.GetUser("alice"); // Returns: null

IsEnabled ​

Checks if user management is active.

csharp
public static bool IsEnabled()

Example:

csharp
if (SilviaUserAPI.IsEnabled()) {
    var user = SilviaUserAPI.GetUser(userId);
} else {
    // Fallback to single-user mode
}

GetUser ​

Gets or creates a user (lazy initialization).

csharp
public static SilviaUser GetUser(string identifier)

Returns: SilviaUser – User object, or null if disabled

Example:

csharp
// First call: Creates user
var user = SilviaUserAPI.GetUser("alice");

// Second call: Returns existing user
var sameUser = SilviaUserAPI.GetUser("alice");

// Different identifier: Creates new user
var bob = SilviaUserAPI.GetUser("bob");

TouchUser ​

Updates user's last activity timestamp.

csharp
public static bool TouchUser(string identifier)

Example:

csharp
// Track user activity
SilviaUserAPI.TouchUser("alice");

// Later: Check inactive users
var manager = SilviaUserAPI.GetManager();
int removed = manager.CleanupInactiveUsers(TimeSpan.FromDays(30));

GetSummary ​

Gets formatted statistics for monitoring.

csharp
public static string GetSummary()

Example:

csharp
string report = SilviaUserAPI.GetSummary();
Console.WriteLine(report);

// Output:
// === SILVIA User Management Summary ===
// Total Users: 1,247
// Max Users: 10,000
// Active (1h/1d/1w): 89/534/1,203
// Total Data Size: 12.43 MB
// Variable Data: 1.25 MB
// Conversation Data: 9.87 MB
// Feedback Data: 1.31 MB
// Total Sessions: 3,891

GetManager ​

Gets the full manager for advanced operations.

csharp
public static SilviaUserManager GetManager()

Example:

csharp
var manager = SilviaUserAPI.GetManager();

// Perform bulk operations
manager.SaveAllUserData("backup/");
var stats = manager.GetStatistics();
var health = manager.GetHealthStatus();

SilviaUserManager ​

Manages the lifecycle of all users.

Constructor ​

csharp
public SilviaUserManager(SilviaCore core, uint maxUsers = 10000)

Example:

csharp
// Usually created via SilviaUserAPI.Enable(), but can be manual:
var manager = new SilviaUserManager(core, 10000);

CreateUser ​

Creates a new user with optional data loading.

csharp
internal SilviaUser CreateUser(string identifier, string dataPath = null)

Parameters:

  • identifier – Unique user ID
  • dataPath – Optional path to load existing user data

Returns: SilviaUser – New or existing user

Example:

csharp
var manager = SilviaUserAPI.GetManager();

// Create new user
var user = manager.CreateUser("alice");

// Create user and load previous session
var returning = manager.CreateUser("bob", "user_data/bob.dat");

Behavior:

  • If user exists: Increments session count, updates timestamp
  • If new: Creates fresh user, optionally loads data
  • Thread-safe with lock(_users)

GetOrCreateUser ​

Gets existing user or creates if missing.

csharp
internal SilviaUser GetOrCreateUser(string identifier)

Example:

csharp
// Same as SilviaUserAPI.GetUser()
var user = manager.GetOrCreateUser("alice");

RemoveUser ​

Removes a user and optionally saves data.

csharp
public bool RemoveUser(string identifier, string savePath = null)

Example:

csharp
// Remove without saving
manager.RemoveUser("inactive_user");

// Remove and save data
manager.RemoveUser("departing_user", "archive/user_departing.dat");

GetUsersByPattern ​

Searches users by identifier pattern.

csharp
internal List<SilviaUser> GetUsersByPattern(string pattern)

Example:

csharp
// Find all admin users
var admins = manager.GetUsersByPattern("admin_");

// Find all users from organization
var orgUsers = manager.GetUsersByPattern("_acme_corp");

TouchUser ​

Updates last activity timestamp.

csharp
public bool TouchUser(string identifier)

Example:

csharp
// Track activity after each interaction
manager.TouchUser("alice");

GetActiveUsers ​

Gets users active within time window.

csharp
internal List<SilviaUser> GetActiveUsers(TimeSpan withinTime)

Example:

csharp
// Users active in last hour
var recentUsers = manager.GetActiveUsers(TimeSpan.FromHours(1));

// Users active today
var todayUsers = manager.GetActiveUsers(TimeSpan.FromDays(1));

Console.WriteLine($"{recentUsers.Count} users active in last hour");

CleanupInactiveUsers ​

Removes users inactive for specified duration.

csharp
public int CleanupInactiveUsers(TimeSpan maxIdleTime, string saveDirectory = null)

Returns: int – Number of users removed

Example:

csharp
// Remove users inactive for 30 days (no save)
int removed = manager.CleanupInactiveUsers(TimeSpan.FromDays(30));

// Remove and save to archive
int archived = manager.CleanupInactiveUsers(
    TimeSpan.FromDays(30),
    "archive/inactive/"
);

Console.WriteLine($"Cleaned up {archived} inactive users");

GetTotalUserDataSize ​

Gets total memory usage of all users.

csharp
public long GetTotalUserDataSize()

Returns: long – Approximate size in bytes

Example:

csharp
long bytes = manager.GetTotalUserDataSize();
double mb = bytes / (1024.0 * 1024.0);

Console.WriteLine($"Total user data: {mb:F2} MB");

GetPerUserDataSizes ​

Gets data size per user.

csharp
public Dictionary<string, long> GetPerUserDataSizes()

Example:

csharp
var sizes = manager.GetPerUserDataSizes();

// Find largest users
var largest = sizes.OrderByDescending(kvp => kvp.Value).Take(10);

foreach (var kvp in largest) {
    Console.WriteLine($"{kvp.Key}: {kvp.Value / 1024.0:F2} KB");
}

SetMaxUsers / GetUserCount ​

Manages user capacity.

csharp
public void SetMaxUsers(uint maxUsers)
public int GetUserCount()

Example:

csharp
// Increase capacity
manager.SetMaxUsers(50000);

// Monitor usage
int current = manager.GetUserCount();
Console.WriteLine($"Users: {current} / 50,000");

SaveAllUserData ​

Saves all users to directory.

csharp
public bool SaveAllUserData(string directory)

Example:

csharp
// Daily backup
manager.SaveAllUserData("backups/daily/");

// Creates files: user_alice.dat, user_bob.dat, etc.

LoadAllUserData ​

Loads all users from directory.

csharp
public int LoadAllUserData(string directory)

Returns: int – Number of users loaded

Example:

csharp
// Restore from backup
int loaded = manager.LoadAllUserData("backups/daily/");
Console.WriteLine($"Restored {loaded} users");

BackupUserData ​

Creates timestamped backup.

csharp
public bool BackupUserData(string backupDirectory)

Example:

csharp
// Automatic backup with timestamp
manager.BackupUserData("backups/");

// Creates: backups/user_backup_20251013_143022/

GetStatistics ​

Gets comprehensive usage statistics.

csharp
public Dictionary<string, object> GetStatistics()

Returns: Dictionary with keys:

  • total_users – Total user count
  • max_users – Maximum capacity
  • total_data_size – Total memory usage
  • active_last_hour – Active users (1 hour)
  • active_last_day – Active users (24 hours)
  • active_last_week – Active users (7 days)
  • variable_data_size – Memory used by variables
  • conversation_data_size – Memory used by conversations
  • feedback_data_size – Memory used by feedback
  • total_sessions – Cumulative session count
  • oldest_user – Creation date of oldest user
  • newest_user – Creation date of newest user

Example:

csharp
var stats = manager.GetStatistics();

Console.WriteLine($"Total Users: {stats["total_users"]}");
Console.WriteLine($"Active (1h): {stats["active_last_hour"]}");
Console.WriteLine($"Memory: {(long)stats["total_data_size"] / (1024*1024)} MB");

GetHealthStatus ​

Performs system health check.

csharp
public Dictionary<string, object> GetHealthStatus()

Returns: Dictionary with keys:

  • status – "healthy", "warning", or "error"
  • user_count – Current users
  • total_data_size – Memory usage
  • active_users – Active in last hour
  • largest_user – User ID with most data
  • largest_user_size – Size of largest user
  • users_per_mb – Average data per user
  • warning / error – Optional issue description

Example:

csharp
var health = manager.GetHealthStatus();

if (health["status"].ToString() == "warning") {
    Console.WriteLine($"Warning: {health["warning"]}");
    
    // Take action
    if ((long)health["largest_user_size"] > 50*1024*1024) {
        string userId = health["largest_user"].ToString();
        Console.WriteLine($"Large user detected: {userId}");
        // Archive or investigate
    }
}

OptimizeMemoryUsage ​

Forces garbage collection.

csharp
public void OptimizeMemoryUsage()

Example:

csharp
// After bulk cleanup
manager.CleanupInactiveUsers(TimeSpan.FromDays(30));
manager.OptimizeMemoryUsage();

GetUserSummary ​

Gets formatted report for dashboards.

csharp
public string GetUserSummary()

Example:

csharp
string report = manager.GetUserSummary();
File.WriteAllText("logs/user_report.txt", report);

// Or send to monitoring system
monitoringAPI.SendMetrics(report);

SilviaUser ​

Individual user session container with isolated data.

Constructor ​

csharp
public SilviaUser(string uid)
public SilviaUser(int iuid)

Note: Usually created via SilviaUserAPI.GetUser() or manager.CreateUser().

GetUid / GetIuid ​

Gets user identifier.

csharp
public string GetUid()
public int GetIuid()

Example:

csharp
var user = SilviaUserAPI.GetUser("alice");
string id = user.GetUid(); // "alice"

Session Metadata ​

Tracks user lifecycle.

csharp
public DateTime GetCreated()        // When user was first created
public DateTime GetLastActive()     // Last interaction timestamp
public int GetSessionCount()        // Number of sessions
public void SetLastActive(DateTime lastActive)
public void SetSessionCount(int sessionCount)
public void UpdateLastActive()      // Sets to DateTime.Now
public void IncrementSessionCount() // Adds 1 to session count

Example:

csharp
var user = SilviaUserAPI.GetUser("alice");

Console.WriteLine($"Created: {user.GetCreated()}");
Console.WriteLine($"Last Active: {user.GetLastActive()}");
Console.WriteLine($"Sessions: {user.GetSessionCount()}");

// Update activity
user.UpdateLastActive();
user.IncrementSessionCount();

GetSessionStats ​

Gets session info as array.

csharp
public string[] GetSessionStats()

Returns: [created, lastActive, sessionCount]

Example:

csharp
var stats = user.GetSessionStats();
Console.WriteLine($"Created: {stats[0]}");
Console.WriteLine($"Last Active: {stats[1]}");
Console.WriteLine($"Sessions: {stats[2]}");

GetDataSize ​

Gets approximate memory usage for this user.

csharp
public long GetDataSize()

Example:

csharp
long bytes = user.GetDataSize();
Console.WriteLine($"User data: {bytes / 1024.0:F2} KB");

User Variables ​

Per-user settings and preferences using $variable convention.

SetUserVariable ​

Sets a user-specific variable.

csharp
public bool SetUserVariable(string name, string value)

Example:

csharp
var user = SilviaUserAPI.GetUser("alice");

// Store user preferences
user.SetUserVariable("$user_name", "Alice Johnson");
user.SetUserVariable("$user_email", "alice@example.com");
user.SetUserVariable("$user_theme", "dark");
user.SetUserVariable("$user_language", "en-US");

Convention: Use $ prefix for SILVIA variable compatibility.

GetUserVariable ​

Retrieves a user variable.

csharp
public string GetUserVariable(string name)

Returns: string – Variable value, or null if not found

Example:

csharp
string name = user.GetUserVariable("$user_name");
string theme = user.GetUserVariable("$user_theme");

if (theme == "dark") {
    ApplyDarkTheme();
}

GetAllUserVariables ​

Gets all variables as name/value array.

csharp
public string[] GetAllUserVariables()

Returns: [name1, value1, name2, value2, ...]

Example:

csharp
string[] vars = user.GetAllUserVariables();

for (int i = 0; i < vars.Length; i += 2) {
    string name = vars[i];
    string value = vars[i + 1];
    Console.WriteLine($"{name} = {value}");
}

RemoveUserVariable / ClearUserVariables ​

Deletes variables.

csharp
public bool RemoveUserVariable(string name)
public void ClearUserVariables()

Example:

csharp
// Remove specific variable
user.RemoveUserVariable("$user_temp");

// Clear all variables
user.ClearUserVariables();

Integration with Brain Responses ​

User variables can be referenced in SILVIA brain exuders:

csharp
// In brain training:
// Exuder: "Welcome back, $user_name! Your balance is $user_balance."

// In code:
var user = SilviaUserAPI.GetUser("alice");
user.SetUserVariable("$user_name", "Alice");
user.SetUserVariable("$user_balance", "$1,234.56");

// When GetResponse is called:
string response = core.ApiBrain().GetResponse("check balance", null);
// Returns: "Welcome back, Alice! Your balance is $1,234.56."

Conversation History ​

Tracks complete input/output exchanges per user.

AddConversation ​

Stores a conversation exchange.

csharp
public bool AddConversation(string userInput, string aiResponse, int behaviorId = -1)

Parameters:

  • userInput – User's message
  • aiResponse – AI's response
  • behaviorId – Behavior that generated response (optional)

Example:

csharp
var user = SilviaUserAPI.GetUser("alice");

// After each exchange
string input = "What's the weather?";
string response = core.ApiBrain().GetResponse(input, null);
int behaviorId = core.ApiBrain().GetResponseBehaviorID(0);

user.AddConversation(input, response, behaviorId);

GetConversationHistory ​

Retrieves conversation history.

csharp
public string[] GetConversationHistory(int maxItems = 0)

Parameters:

  • maxItems – Max items to return (0 = all, returns most recent)

Returns: [input1, response1, behaviorId1, timestamp1, input2, response2, ...]

Example:

csharp
// Get last 10 exchanges
string[] history = user.GetConversationHistory(10);

for (int i = 0; i < history.Length; i += 4) {
    string input = history[i];
    string response = history[i + 1];
    string behaviorId = history[i + 2];
    string timestamp = history[i + 3];
    
    Console.WriteLine($"[{timestamp}] User: {input}");
    Console.WriteLine($"[{timestamp}] AI: {response} (Behavior: {behaviorId})");
}

GetLastConversation ​

Gets most recent exchange.

csharp
public string[] GetLastConversation()

Returns: [input, response, behaviorId, timestamp]

Example:

csharp
string[] last = user.GetLastConversation();

if (last.Length > 0) {
    Console.WriteLine($"Last input: {last[0]}");
    Console.WriteLine($"Last response: {last[1]}");
}

ClearConversationHistory ​

Deletes all conversation history.

csharp
public void ClearConversationHistory()

Example:

csharp
// Start fresh conversation
user.ClearConversationHistory();

Use Case: Context-Aware Responses ​

csharp
// User asks follow-up question
string input = "And what about tomorrow?";
string response = core.ApiBrain().GetResponse(input, null);

// Check conversation history for context
string[] history = user.GetConversationHistory(5);

// If previous question was about weather:
if (history[0].Contains("weather")) {
    // AI can reference context
    // Response: "Tomorrow will be sunny with a high of 75°F."
}

Feedback Management ​

Stores learning feedback for conversational improvement.

AddUserFeedback ​

Adds feedback entry.

csharp
public bool AddUserFeedback(string feedback, string context = null)

Parameters:

  • feedback – Feedback text
  • context – Optional context (input that triggered feedback)

Example:

csharp
var user = SilviaUserAPI.GetUser("alice");

// Positive feedback
user.AddUserFeedback("That was helpful!", "weather query");

// Negative feedback
user.AddUserFeedback("I didn't understand that", "unclear response");

// Correction
user.AddUserFeedback("My name is Alice, not Alex", "name recognition");

GetUserFeedbackHistory ​

Retrieves feedback history.

csharp
public string[] GetUserFeedbackHistory(int maxItems = 0)

Returns: [feedback1, context1, timestamp1, feedback2, context2, timestamp2, ...]

Example:

csharp
// Get last 20 feedback items
string[] feedback = user.GetUserFeedbackHistory(20);

for (int i = 0; i < feedback.Length; i += 3) {
    string text = feedback[i];
    string context = feedback[i + 1];
    string timestamp = feedback[i + 2];
    
    Console.WriteLine($"[{timestamp}] {text}");
    if (!string.IsNullOrEmpty(context)) {
        Console.WriteLine($"  Context: {context}");
    }
}

SearchUserFeedback ​

Searches feedback for patterns.

csharp
public string[] SearchUserFeedback(string searchTerm, int maxResults = 10)

Example:

csharp
// Find negative feedback
string[] negative = user.SearchUserFeedback("didn't understand", 10);

// Find feedback about specific topic
string[] weatherFeedback = user.SearchUserFeedback("weather", 5);

ClearUserFeedbackHistory ​

Deletes all feedback.

csharp
public void ClearUserFeedbackHistory()

Memory & State Integration ​

Future integration with SILVIA's advanced learning systems.

Memory Integration ​

Per-user concept storage.

csharp
internal SilviaMemory GetUserMemory()
public bool AddToUserMemory(int[] atoms, bool asInput)
public List<object> GetUserMemoryConcepts(int conceptId = -1)

Example (Future):

csharp
// Add concepts to user's memory
int[] concepts = core.ApiBrain().GetConceptsAsStrings("machine learning", false, false);
user.AddToUserMemory(concepts, true);

// Retrieve user's memory concepts
var memoryConcepts = user.GetUserMemoryConcepts();

Note: Requires SilviaMemory initialization with parent brain.

State Integration ​

Per-user event queues.

csharp
internal SilviaState GetUserState()
public bool PostUserEvent(string eventName, int behaviorId = -1, int exuderId = -1)
public bool ConsumeUserEvent(string eventName)

Example (Future):

csharp
// Post user-specific event
user.PostUserEvent("completed_tutorial", behaviorId, exuderId);

// Check and consume event
if (user.ConsumeUserEvent("completed_tutorial")) {
    // Award badge, update progress
}

Note: Requires SilviaState initialization with parent brain.

Session Management ​

UpdateLastActive ​

Marks user as active.

csharp
public void UpdateLastActive()

Example:

csharp
// After each user interaction
user.UpdateLastActive();

IncrementSessionCount ​

Tracks sessions.

csharp
public void IncrementSessionCount()

Example:

csharp
// On user login/reconnect
user.IncrementSessionCount();

Session Lifecycle ​

csharp
void HandleUserConnection(string userId) {
    var user = SilviaUserAPI.GetUser(userId);
    
    // Check if returning user
    if (user.GetSessionCount() > 1) {
        // Returning user
        TimeSpan idle = DateTime.Now - user.GetLastActive();
        Console.WriteLine($"Welcome back! Idle for {idle.TotalHours:F1} hours");
    } else {
        // New user
        Console.WriteLine("Welcome! This is your first session.");
    }
    
    // Update session
    user.IncrementSessionCount();
    user.UpdateLastActive();
}

Persistence & Backup ​

SaveUserData ​

Saves user to file.

csharp
public bool SaveUserData(string filename)

File Format:

# SILVIA User Data - alice
# Created: 10/13/2025 2:30:15 PM
# Last Active: 10/13/2025 4:45:22 PM
# Session Count: 7

# USER VARIABLES
VAR:$user_name:Alice Johnson
VAR:$user_email:alice@example.com

# CONVERSATION HISTORY
CONV:2025-10-13 14:30:20:What's the weather?:It's sunny, 72°F:42
CONV:2025-10-13 14:31:15:And tomorrow?:Tomorrow will be partly cloudy, 68°F:42

# FEEDBACK HISTORY
FEED:2025-10-13 14:31:30:That was helpful:weather query

Example:

csharp
// Save specific user
user.SaveUserData("user_data/alice.dat");

// Automated saves
void AutoSaveUser(SilviaUser user) {
    string path = $"user_data/{user.GetUid()}.dat";
    if (user.SaveUserData(path)) {
        Console.WriteLine($"Saved user: {user.GetUid()}");
    }
}

LoadUserData ​

Loads user from file.

csharp
public bool LoadUserData(string filename)

Example:

csharp
var user = SilviaUserAPI.GetUser("alice");

// Load previous session
if (user.LoadUserData("user_data/alice.dat")) {
    Console.WriteLine("Restored user session");
    
    // User variables, conversations, feedback are restored
    string name = user.GetUserVariable("$user_name");
    string[] history = user.GetConversationHistory(5);
}

Backup Strategies ​

Daily Backup ​

csharp
// Scheduled task
void DailyBackup() {
    var manager = SilviaUserAPI.GetManager();
    
    string timestamp = DateTime.Now.ToString("yyyyMMdd");
    string backupPath = $"backups/daily_{timestamp}/";
    
    manager.SaveAllUserData(backupPath);
    
    Console.WriteLine($"Backed up {manager.GetUserCount()} users");
}

Rolling Backup ​

csharp
void RollingBackup() {
    var manager = SilviaUserAPI.GetManager();
    
    // Keep 7 days of backups
    for (int i = 6; i >= 0; i--) {
        DateTime date = DateTime.Now.AddDays(-i);
        string path = $"backups/{date:yyyyMMdd}/";
        
        if (i == 0) {
            // Today's backup
            manager.SaveAllUserData(path);
        } else if (i > 7) {
            // Delete old backups
            if (Directory.Exists(path)) {
                Directory.Delete(path, true);
            }
        }
    }
}

Incremental Backup ​

csharp
void IncrementalBackup() {
    var manager = SilviaUserAPI.GetManager();
    
    // Only backup active users
    var activeUsers = manager.GetActiveUsers(TimeSpan.FromHours(24));
    
    foreach (var user in activeUsers) {
        string path = $"incremental/{user.GetUid()}.dat";
        user.SaveUserData(path);
    }
    
    Console.WriteLine($"Incrementally backed up {activeUsers.Count} active users");
}

Resource Management ​

Memory Monitoring ​

csharp
void MonitorMemoryUsage() {
    var manager = SilviaUserAPI.GetManager();
    
    long totalBytes = manager.GetTotalUserDataSize();
    double totalMB = totalBytes / (1024.0 * 1024.0);
    
    int userCount = manager.GetUserCount();
    double avgMB = totalMB / userCount;
    
    Console.WriteLine($"Total Memory: {totalMB:F2} MB");
    Console.WriteLine($"Users: {userCount}");
    Console.WriteLine($"Avg per user: {avgMB:F3} MB");
    
    // Alert if high
    if (totalMB > 500) {
        Console.WriteLine("WARNING: High memory usage!");
        
        // Find large users
        var sizes = manager.GetPerUserDataSizes();
        var largest = sizes.OrderByDescending(kvp => kvp.Value).Take(10);
        
        Console.WriteLine("Largest users:");
        foreach (var kvp in largest) {
            double mb = kvp.Value / (1024.0 * 1024.0);
            Console.WriteLine($"  {kvp.Key}: {mb:F2} MB");
        }
    }
}

Cleanup Strategies ​

Age-Based Cleanup ​

csharp
void CleanupOldUsers() {
    var manager = SilviaUserAPI.GetManager();
    
    // Remove users inactive for 90 days
    int removed = manager.CleanupInactiveUsers(
        TimeSpan.FromDays(90),
        "archive/"
    );
    
    Console.WriteLine($"Archived {removed} inactive users");
}

Size-Based Cleanup ​

csharp
void CleanupLargeUsers() {
    var manager = SilviaUserAPI.GetManager();
    var sizes = manager.GetPerUserDataSizes();
    
    // Remove users with >50MB data
    int removed = 0;
    foreach (var kvp in sizes) {
        if (kvp.Value > 50 * 1024 * 1024) {
            manager.RemoveUser(kvp.Key, $"archive/{kvp.Key}.dat");
            removed++;
        }
    }
    
    Console.WriteLine($"Archived {removed} large users");
}

Activity-Based Retention ​

csharp
void SmartCleanup() {
    var manager = SilviaUserAPI.GetManager();
    
    // Keep active users
    var activeLastWeek = manager.GetActiveUsers(TimeSpan.FromDays(7));
    var activeLastMonth = manager.GetActiveUsers(TimeSpan.FromDays(30));
    var activeLastYear = manager.GetActiveUsers(TimeSpan.FromDays(365));
    
    Console.WriteLine($"Active last week: {activeLastWeek.Count}");
    Console.WriteLine($"Active last month: {activeLastMonth.Count}");
    Console.WriteLine($"Active last year: {activeLastYear.Count}");
    
    // Remove inactive for 1 year
    int removed = manager.CleanupInactiveUsers(TimeSpan.FromDays(365), "cold_storage/");
    Console.WriteLine($"Moved {removed} users to cold storage");
}

Statistics & Monitoring ​

Real-Time Dashboard ​

csharp
void DisplayDashboard() {
    var manager = SilviaUserAPI.GetManager();
    var stats = manager.GetStatistics();
    var health = manager.GetHealthStatus();
    
    Console.Clear();
    Console.WriteLine("╔════════════════════════════════════════════════════════╗");
    Console.WriteLine("║           SILVIA User Management Dashboard            ║");
    Console.WriteLine("╠════════════════════════════════════════════════════════╣");
    Console.WriteLine($"║ Total Users:        {stats["total_users"],-34} ║");
    Console.WriteLine($"║ Max Capacity:       {stats["max_users"],-34} ║");
    Console.WriteLine($"║ Health Status:      {health["status"],-34} ║");
    Console.WriteLine("╠════════════════════════════════════════════════════════╣");
    Console.WriteLine($"║ Active (1 hour):    {stats["active_last_hour"],-34} ║");
    Console.WriteLine($"║ Active (24 hours):  {stats["active_last_day"],-34} ║");
    Console.WriteLine($"║ Active (7 days):    {stats["active_last_week"],-34} ║");
    Console.WriteLine("╠════════════════════════════════════════════════════════╣");
    
    long totalBytes = (long)stats["total_data_size"];
    double totalMB = totalBytes / (1024.0 * 1024.0);
    Console.WriteLine($"║ Total Memory:       {totalMB:F2} MB{"",-26} ║");
    
    Console.WriteLine($"║ Total Sessions:     {stats["total_sessions"],-34} ║");
    Console.WriteLine("╚════════════════════════════════════════════════════════╝");
    
    // Warnings
    if (health["status"].ToString() != "healthy") {
        Console.WriteLine($"\n⚠️  WARNING: {health.GetValueOrDefault("warning", "Unknown issue")}");
    }
}

Metrics Export ​

csharp
void ExportMetrics() {
    var manager = SilviaUserAPI.GetManager();
    var stats = manager.GetStatistics();
    
    // Export to Prometheus format
    var prometheus = new StringBuilder();
    prometheus.AppendLine($"silvia_users_total {stats["total_users"]}");
    prometheus.AppendLine($"silvia_users_active_1h {stats["active_last_hour"]}");
    prometheus.AppendLine($"silvia_users_active_24h {stats["active_last_day"]}");
    prometheus.AppendLine($"silvia_users_active_7d {stats["active_last_week"]}");
    prometheus.AppendLine($"silvia_memory_bytes {stats["total_data_size"]}");
    prometheus.AppendLine($"silvia_sessions_total {stats["total_sessions"]}");
    
    File.WriteAllText("metrics/silvia_metrics.prom", prometheus.ToString());
    
    // Export to JSON
    string json = JsonConvert.SerializeObject(stats, Formatting.Indented);
    File.WriteAllText("metrics/silvia_stats.json", json);
}

Alert System ​

csharp
void CheckAlerts() {
    var manager = SilviaUserAPI.GetManager();
    var health = manager.GetHealthStatus();
    
    // Check user capacity
    int userCount = manager.GetUserCount();
    int maxUsers = 10000;
    double usagePercent = (userCount / (double)maxUsers) * 100;
    
    if (usagePercent > 90) {
        SendAlert($"CRITICAL: User capacity at {usagePercent:F1}%");
    } else if (usagePercent > 75) {
        SendAlert($"WARNING: User capacity at {usagePercent:F1}%");
    }
    
    // Check memory usage
    long memoryBytes = manager.GetTotalUserDataSize();
    double memoryMB = memoryBytes / (1024.0 * 1024.0);
    
    if (memoryMB > 1000) {
        SendAlert($"CRITICAL: User data exceeds 1 GB ({memoryMB:F0} MB)");
    } else if (memoryMB > 500) {
        SendAlert($"WARNING: User data exceeds 500 MB ({memoryMB:F0} MB)");
    }
    
    // Check health status
    if (health["status"].ToString() != "healthy") {
        SendAlert($"Health check failed: {health.GetValueOrDefault("warning", "Unknown")}");
    }
}

void SendAlert(string message) {
    Console.WriteLine($"[ALERT] {DateTime.Now}: {message}");
    // Send email, webhook, etc.
}

Platform-Specific Integrations ​

ASP.NET Core Middleware ​

csharp
// Startup.cs
public void ConfigureServices(IServiceCollection services) {
    // Enable user management
    services.AddSingleton<ISilviaService>(provider => {
        var core = SilviaCoreManager.CreateCore("web_core", "chatbot.sil", true);
        SilviaUserAPI.Enable(core, 50000);
        return new SilviaService(core);
    });
}

// SilviaService.cs
public class SilviaService : ISilviaService {
    private SilviaCore _core;
    
    public SilviaService(SilviaCore core) {
        _core = core;
    }
    
    public async Task<ChatResponse> GetResponseAsync(string userId, string input) {
        return await Task.Run(() => {
            // Get user
            var user = SilviaUserAPI.GetUser(userId);
            
            // Load user context
            string userName = user.GetUserVariable("$user_name") ?? "Guest";
            user.SetUserVariable("$last_input", input);
            
            // Get AI response
            string response = _core.ApiBrain().GetResponse(input, null);
            int behaviorId = _core.ApiBrain().GetResponseBehaviorID(0);
            
            // Store conversation
            user.AddConversation(input, response, behaviorId);
            user.UpdateLastActive();
            
            return new ChatResponse {
                Text = response,
                BehaviorId = behaviorId,
                UserName = userName
            };
        });
    }
}

// Controller
[ApiController]
[Route("api/[controller]")]
public class ChatController : ControllerBase {
    private readonly ISilviaService _silvia;
    
    public ChatController(ISilviaService silvia) {
        _silvia = silvia;
    }
    
    [HttpPost]
    public async Task<IActionResult> Chat([FromBody] ChatRequest request) {
        string userId = User.Identity.Name ?? request.SessionId;
        var response = await _silvia.GetResponseAsync(userId, request.Message);
        return Ok(response);
    }
    
    [HttpGet("history")]
    public IActionResult GetHistory() {
        string userId = User.Identity.Name;
        var user = SilviaUserAPI.GetUser(userId);
        
        string[] history = user.GetConversationHistory(20);
        return Ok(new { history });
    }
}

SignalR Real-Time Chat ​

csharp
public class ChatHub : Hub {
    private SilviaCore _core;
    
    public ChatHub(ISilviaService silvia) {
        _core = silvia.GetCore();
    }
    
    public async Task SendMessage(string message) {
        string userId = Context.UserIdentifier ?? Context.ConnectionId;
        var user = SilviaUserAPI.GetUser(userId);
        
        // Get response
        string response = _core.ApiBrain().GetResponse(message, null);
        
        // Store conversation
        user.AddConversation(message, response);
        user.UpdateLastActive();
        
        // Send to client
        await Clients.Caller.SendAsync("ReceiveMessage", response);
    }
    
    public async Task GetHistory() {
        string userId = Context.UserIdentifier ?? Context.ConnectionId;
        var user = SilviaUserAPI.GetUser(userId);
        
        string[] history = user.GetConversationHistory(10);
        await Clients.Caller.SendAsync("LoadHistory", history);
    }
}

Azure Functions ​

csharp
[FunctionName("SilviaChat")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req,
    ILogger log)
{
    // Initialize (once per function instance)
    if (!SilviaUserAPI.IsEnabled()) {
        var core = SilviaCoreManager.CreateCore("azure_core", "brain.sil", true);
        SilviaUserAPI.Enable(core, 100000);
    }
    
    // Parse request
    string requestBody = await req.ReadAsStringAsync();
    dynamic data = JsonConvert.DeserializeObject(requestBody);
    string userId = data?.userId;
    string input = data?.message;
    
    // Get user
    var user = SilviaUserAPI.GetUser(userId);
    
    // Get response
    var core = SilviaCoreManager.GetCore("azure_core");
    string response = core.ApiBrain().GetResponse(input, null);
    
    // Store and return
    user.AddConversation(input, response);
    user.UpdateLastActive();
    
    return new OkObjectResult(new {
        response,
        userId,
        timestamp = DateTime.Now
    });
}

Unity Game ​

csharp
public class SilviaManager : MonoBehaviour {
    private SilviaCore _core;
    private string _playerId;
    
    void Start() {
        // Load brain
        TextAsset brainAsset = Resources.Load<TextAsset>("Brains/game_brain");
        using (var ms = new MemoryStream(brainAsset.bytes)) {
            using (var br = new BinaryReader(ms)) {
                _core = SilviaCoreManager.CreateCore("game_core", null, false);
                _core.ApiBrain().LoadStream(br, null, false, true);
            }
        }
        
        // Enable user management
        SilviaUserAPI.Enable(_core, 10000);
        
        // Get player ID
        _playerId = SystemInfo.deviceUniqueIdentifier;
        
        // Load player data
        var user = SilviaUserAPI.GetUser(_playerId);
        string savePath = Path.Combine(Application.persistentDataPath, $"player_{_playerId}.dat");
        user.LoadUserData(savePath);
        
        Debug.Log($"Player session count: {user.GetSessionCount()}");
    }
    
    public void SendMessage(string input) {
        var user = SilviaUserAPI.GetUser(_playerId);
        
        // Set player context
        user.SetUserVariable("$player_name", PlayerPrefs.GetString("PlayerName"));
        user.SetUserVariable("$player_level", PlayerPrefs.GetInt("Level").ToString());
        
        // Get response
        string response = _core.ApiBrain().GetResponse(input, null);
        
        // Store conversation
        user.AddConversation(input, response);
        user.UpdateLastActive();
        
        // Display in UI
        chatUI.AddMessage("AI", response);
    }
    
    void OnApplicationQuit() {
        // Save player data
        var user = SilviaUserAPI.GetUser(_playerId);
        string savePath = Path.Combine(Application.persistentDataPath, $"player_{_playerId}.dat");
        user.SaveUserData(savePath);
    }
}

Discord Bot ​

csharp
public class SilviaDiscordBot {
    private DiscordSocketClient _client;
    private SilviaCore _core;
    
    public async Task MainAsync() {
        // Initialize SILVIA
        _core = SilviaCoreManager.CreateCore("discord_core", "discord_brain.sil", true);
        SilviaUserAPI.Enable(_core, 100000);
        
        // Initialize Discord
        _client = new DiscordSocketClient();
        _client.MessageReceived += HandleMessage;
        
        await _client.LoginAsync(TokenType.Bot, Environment.GetEnvironmentVariable("DISCORD_TOKEN"));
        await _client.StartAsync();
        
        await Task.Delay(-1);
    }
    
    private async Task HandleMessage(SocketMessage message) {
        if (message.Author.IsBot) return;
        
        string userId = message.Author.Id.ToString();
        var user = SilviaUserAPI.GetUser(userId);
        
        // Set user context
        user.SetUserVariable("$user_name", message.Author.Username);
        user.SetUserVariable("$user_discriminator", message.Author.Discriminator);
        
        // Get response
        string response = _core.ApiBrain().GetResponse(message.Content, null);
        
        // Store conversation
        user.AddConversation(message.Content, response);
        user.UpdateLastActive();
        
        // Reply
        await message.Channel.SendMessageAsync(response);
    }
}

Best Practices ​

1. Enable User Management Strategically ​

csharp
// For single-user applications: DON'T enable
var core = SilviaCoreManager.CreateCore("single_user", "brain.sil", true);
// No user management overhead

// For multi-user servers: DO enable
var core = SilviaCoreManager.CreateCore("multi_user", "brain.sil", true);
SilviaUserAPI.Enable(core, 10000);

2. Use User Variables for Personalization ​

csharp
void PersonalizeResponse(SilviaUser user, string input) {
    // Load user preferences
    string name = user.GetUserVariable("$user_name");
    string language = user.GetUserVariable("$user_language") ?? "en-US";
    string timezone = user.GetUserVariable("$user_timezone") ?? "UTC";
    
    // Set context for this request
    user.SetUserVariable("$current_time", DateTime.Now.ToString());
    user.SetUserVariable("$current_input", input);
    
    // Brain exuders can now reference these variables
    string response = _core.ApiBrain().GetResponse(input, null);
}

3. Implement Graceful Degradation ​

csharp
string GetResponse(string userId, string input) {
    SilviaUser user = null;
    
    try {
        // Try user-specific mode
        if (SilviaUserAPI.IsEnabled()) {
            user = SilviaUserAPI.GetUser(userId);
            
            // Load user context
            string userName = user.GetUserVariable("$user_name");
            if (!string.IsNullOrEmpty(userName)) {
                _core.SetVariable("$user_name", userName);
            }
        }
        
        // Get response
        string response = _core.ApiBrain().GetResponse(input, null);
        
        // Store if user management enabled
        if (user != null) {
            user.AddConversation(input, response);
            user.UpdateLastActive();
        }
        
        return response;
        
    } catch (Exception ex) {
        Console.WriteLine($"Error: {ex.Message}");
        return "I'm having trouble processing that right now.";
    }
}

4. Regular Maintenance ​

csharp
// Run daily
void DailyMaintenance() {
    var manager = SilviaUserAPI.GetManager();
    
    // 1. Backup all users
    manager.BackupUserData("backups/");
    
    // 2. Cleanup inactive users
    int removed = manager.CleanupInactiveUsers(TimeSpan.FromDays(90), "archive/");
    Console.WriteLine($"Archived {removed} inactive users");
    
    // 3. Optimize memory
    manager.OptimizeMemoryUsage();
    
    // 4. Generate report
    var stats = manager.GetStatistics();
    var report = manager.GetUserSummary();
    File.WriteAllText("logs/daily_report.txt", report);
    
    // 5. Check health
    var health = manager.GetHealthStatus();
    if (health["status"].ToString() != "healthy") {
        SendAlert($"User management health: {health["status"]}");
    }
}

5. Monitor Resource Usage ​

csharp
// Run every 5 minutes
void MonitorResources() {
    var manager = SilviaUserAPI.GetManager();
    
    // Check memory
    long bytes = manager.GetTotalUserDataSize();
    double mb = bytes / (1024.0 * 1024.0);
    
    if (mb > 1000) {
        // Over 1GB - take action
        Console.WriteLine($"WARNING: User data at {mb:F0} MB");
        
        // Find and archive large users
        var sizes = manager.GetPerUserDataSizes();
        foreach (var kvp in sizes.OrderByDescending(x => x.Value).Take(10)) {
            if (kvp.Value > 10 * 1024 * 1024) { // 10MB
                var user = manager.GetUser(kvp.Key);
                user.SaveUserData($"archive/{kvp.Key}.dat");
                manager.RemoveUser(kvp.Key);
            }
        }
    }
    
    // Check user count
    int count = manager.GetUserCount();
    if (count > 9000) {
        Console.WriteLine($"WARNING: Approaching max users ({count}/10,000)");
        // Consider increasing capacity or cleanup
    }
}

6. Implement Session Resumption ​

csharp
void ResumeUserSession(string userId) {
    var user = SilviaUserAPI.GetUser(userId);
    
    // Load previous session if exists
    string dataPath = $"user_data/{userId}.dat";
    if (File.Exists(dataPath)) {
        user.LoadUserData(dataPath);
        
        // Check session age
        TimeSpan idle = DateTime.Now - user.GetLastActive();
        
        if (idle.TotalDays > 7) {
            // Old session - clear conversation history
            user.ClearConversationHistory();
            SendMessage("Welcome back! It's been a while.");
        } else if (idle.TotalHours > 1) {
            // Recent session - resume context
            var lastConv = user.GetLastConversation();
            if (lastConv.Length > 0) {
                SendMessage($"Continuing from: \"{lastConv[0]}\"");
            }
        } else {
            // Active session
            SendMessage("Welcome back!");
        }
    } else {
        // New user
        SendMessage("Welcome! I'm SILVIA. How can I help you?");
    }
    
    // Update session
    user.IncrementSessionCount();
    user.UpdateLastActive();
}

7. Thread Safety ​

csharp
// CORRECT: User management handles locking internally
void HandleConcurrentRequests() {
    Parallel.For(0, 100, i => {
        var user = SilviaUserAPI.GetUser($"user_{i % 10}"); // 10 users, 100 requests
        user.SetUserVariable("$counter", i.ToString());
        user.UpdateLastActive();
    });
    // No race conditions - internal locking protects data
}

// CORRECT: Multiple threads can access same user safely
var tasks = new Task[10];
for (int i = 0; i < 10; i++) {
    tasks[i] = Task.Run(() => {
        var user = SilviaUserAPI.GetUser("alice");
        string name = user.GetUserVariable("$user_name"); // Safe concurrent read
    });
}
Task.WaitAll(tasks);

8. Error Handling ​

csharp
string SafeGetResponse(string userId, string input) {
    try {
        // Check if user management enabled
        if (!SilviaUserAPI.IsEnabled()) {
            // Fallback to single-user mode
            return _core.ApiBrain().GetResponse(input, null);
        }
        
        // Get user
        var user = SilviaUserAPI.GetUser(userId);
        if (user == null) {
            Console.WriteLine($"Failed to create user: {userId}");
            return "I'm having trouble with your session right now.";
        }
        
        // Check user data size
        long userSize = user.GetDataSize();
        if (userSize > 50 * 1024 * 1024) { // 50MB
            Console.WriteLine($"User {userId} data size exceeded limit: {userSize} bytes");
            // Archive and clear
            user.SaveUserData($"archive/{userId}.dat");
            user.ClearConversationHistory();
            user.ClearUserFeedbackHistory();
        }
        
        // Get response
        string response = _core.ApiBrain().GetResponse(input, null);
        
        // Store conversation
        if (!user.AddConversation(input, response)) {
            Console.WriteLine($"Failed to store conversation for user: {userId}");
        }
        
        user.UpdateLastActive();
        return response;
        
    } catch (OutOfMemoryException) {
        Console.WriteLine("Out of memory - running cleanup");
        var manager = SilviaUserAPI.GetManager();
        manager.CleanupInactiveUsers(TimeSpan.FromHours(1));
        manager.OptimizeMemoryUsage();
        return "System is experiencing high load. Please try again.";
        
    } catch (Exception ex) {
        Console.WriteLine($"Error processing request: {ex.Message}");
        return "I encountered an error. Please try again.";
    }
}

API Summary ​

SilviaUserAPI (Static) ​

  • Enable(core, maxUsers) – Activate user management
  • Disable() – Deactivate user management
  • IsEnabled() – Check if enabled
  • GetUser(identifier) – Get or create user
  • TouchUser(identifier) – Update activity
  • GetSummary() – Get formatted report
  • GetManager() – Get manager instance

SilviaUserManager ​

Lifecycle:

  • CreateUser(identifier, dataPath) – Create new user
  • GetOrCreateUser(identifier) – Get or create
  • RemoveUser(identifier, savePath) – Remove user
  • GetUsersByPattern(pattern) – Search users

Session:

  • TouchUser(identifier) – Update activity
  • GetActiveUsers(withinTime) – Get active users
  • CleanupInactiveUsers(maxIdleTime, saveDirectory) – Remove inactive

Resources:

  • GetTotalUserDataSize() – Total memory usage
  • GetPerUserDataSizes() – Per-user sizes
  • SetMaxUsers(maxUsers) – Set capacity
  • GetUserCount() – Current count

Persistence:

  • SaveAllUserData(directory) – Save all
  • LoadAllUserData(directory) – Load all
  • BackupUserData(backupDirectory) – Create backup

Monitoring:

  • GetStatistics() – Comprehensive stats
  • GetHealthStatus() – Health check
  • OptimizeMemoryUsage() – Force GC
  • GetUserSummary() – Formatted report

SilviaUser ​

Identity:

  • GetUid() / GetIuid() – Get identifier
  • GetCreated() – Creation timestamp
  • GetLastActive() – Last activity
  • GetSessionCount() – Session count

Variables:

  • SetUserVariable(name, value) – Set variable
  • GetUserVariable(name) – Get variable
  • GetAllUserVariables() – Get all variables
  • RemoveUserVariable(name) – Remove variable
  • ClearUserVariables() – Clear all

Conversations:

  • AddConversation(input, response, behaviorId) – Store exchange
  • GetConversationHistory(maxItems) – Get history
  • GetLastConversation() – Get most recent
  • ClearConversationHistory() – Clear history

Feedback:

  • AddUserFeedback(feedback, context) – Add feedback
  • GetUserFeedbackHistory(maxItems) – Get history
  • SearchUserFeedback(searchTerm, maxResults) – Search feedback
  • ClearUserFeedbackHistory() – Clear history

Memory & State:

  • GetUserMemory() – Get memory object
  • AddToUserMemory(atoms, asInput) – Add concepts
  • GetUserMemoryConcepts(conceptId) – Get concepts
  • GetUserState() – Get state object
  • PostUserEvent(eventName, behaviorId, exuderId) – Post event
  • ConsumeUserEvent(eventName) – Consume event

Session:

  • UpdateLastActive() – Mark active
  • IncrementSessionCount() – Increment sessions
  • GetSessionStats() – Get stats array
  • GetDataSize() – Get memory usage

Persistence:

  • SaveUserData(filename) – Save to file
  • LoadUserData(filename) – Load from file

Remarks ​

ApiUser Manages SILVIA's scalability:

Default Config:

  • 1 core = 1 user
  • Instanced Knowledgebases Per-User

Multi-User Per Core:

  • 1 core = 10,000 users
  • Shared Knowledgebase Per-Core
  • 10K users = 550 MB memory
  • Simple single-core management

This breakthrough enables:

  • Enterprise SaaS: Massive multi-tenancy
  • IoT Platforms: Millions of device sessions
  • Gaming Servers: Thousands of players per instance
  • Cloud APIs: Cost-effective scaling

Optional activation means zero impact on existing deployments while providing a game-changing architectural improvement for new multi-user systems.

© Copyright Cognitive Code Corp. 2007-2026

SILVIA is a registered Trademark of Cognitive Code Corp.

SILVIA is a registered Trademark of Cognitive Code Corp.

© Copyright Cognitive Code Corp. 2007-2026