Code Examples

1import { SafetyGuard } from '@akioudai/safety-sdk';
2
3// Initialize the safety guard with content filtering
4const guard = new SafetyGuard({
5  apiKey: process.env.AKIOUDAI_API_KEY,
6  boundaries: ['toxicity', 'hate', 'sexual', 'violence'],
7  threshold: 0.85,
8  mode: 'filter' // 'filter', 'block', or 'monitor'
9});
10
11async function filterUserContent(content) {
12  try {
13    // Apply content filtering
14    const result = await guard.filter(content, {
15      context: {
16        audience: 'general',
17        domain: 'customer-service'
18      }
19    });
20    
21    // Check if content was modified
22    if (result.modified) {
23      console.log('Content was filtered for safety');
24      console.log('Original:', content);
25      console.log('Filtered:', result.filteredContent);
26      console.log('Issues:', result.issues);
27      
28      return {
29        content: result.filteredContent,
30        safe: true,
31        modified: true,
32        issues: result.issues
33      };
34    }
35    
36    return {
37      content: content,
38      safe: true,
39      modified: false
40    };
41  } catch (error) {
42    console.error('Error filtering content:', error);
43    return {
44      content: 'I cannot process this content due to safety concerns.',
45      safe: false,
46      error: error.message
47    };
48  }
49}
50
51// Example usage
52const userMessage = "Your message here";
53const filteredResult = await filterUserContent(userMessage);
54displayMessage(filteredResult.content);

1import { SafetyGuard } from '@akioudai/safety-sdk';
2
3// Initialize with toxicity detection focus
4const toxicityDetector = new SafetyGuard({
5  apiKey: process.env.AKIOUDAI_API_KEY,
6  boundaries: ['toxicity'],
7  threshold: 0.75,
8  mode: 'monitor'
9});
10
11// Create a monitoring function
12async function monitorForToxicity(conversation) {
13  const messages = conversation.getMessages();
14  const lastMessage = messages[messages.length - 1];
15  
16  // Skip if not from user
17  if (lastMessage.role !== 'user') return;
18  
19  const result = await toxicityDetector.monitor(lastMessage.content, {
20    realtime: true,
21    context: {
22      conversationHistory: messages.slice(0, -1).map(m => ({
23        role: m.role,
24        content: m.content
25      }))
26    }
27  });
28  
29  if (!result.safe) {
30    // Handle toxic content
31    conversation.addSystemMessage(
32      "I've detected potentially harmful content. Please maintain respectful communication."
33    );
34    
35    // Log the incident
36    logSafetyIncident({
37      type: 'toxicity',
38      score: result.score,
39      message: lastMessage.content,
40      timestamp: new Date()
41    });
42    
43    // For severe violations, take additional action
44    if (result.score > 0.9) {
45      notifyModerators({
46        conversationId: conversation.id,
47        messageId: lastMessage.id,
48        violation: result.violations[0]
49      });
50    }
51  }
52}
53
54// Set up monitoring on a chat interface
55chatInterface.on('message', message => {
56  monitorForToxicity(chatInterface.conversation);
57});

1import { AgentAlignment } from '@akioudai/safety-sdk';
2
3// Define custom alignment objectives for a financial advisor agent
4const financialAdvisorAlignment = new AgentAlignment({
5  apiKey: process.env.AKIOUDAI_API_KEY,
6  objectives: [
7    'regulatory_compliance',
8    'factual_accuracy',
9    'fiduciary_responsibility',
10    'risk_disclosure'
11  ],
12  frameworks: ['sec_regulations', 'finra_guidelines'],
13  threshold: 0.98
14});
15
16// Custom regulatory dictionary for finance
17const regulatoryDictionary = {
18  terms: [
19    { term: 'guaranteed returns', alternatives: ['historical performance', 'potential returns'] },
20    { term: 'risk-free', alternatives: ['lower-risk', 'historically stable'] },
21    { term: 'certain profit', alternatives: ['potential growth', 'investment objective'] }
22  ],
23  disclosures: [
24    'Past performance is not indicative of future results',
25    'Investments involve risk and may lose value',
26    'This is not financial advice and should not be construed as such'
27  ]
28};
29
30// Apply alignment to the model
31const alignedModel = await financialAdvisorAlignment.alignAgent(baseModel, {
32  customDictionaries: [regulatoryDictionary],
33  interventions: {
34    onMisalignment: (output, issue) => {
35      // Add appropriate financial disclaimer
36      const disclaimer = regulatoryDictionary.disclosures.find(d => 
37        d.toLowerCase().includes(issue.category.toLowerCase())
38      ) || regulatoryDictionary.disclosures[0];
39      
40      return output + "\n\n*Disclaimer: " + disclaimer + "*";
41    }
42  }
43});
44
45// Deploy the aligned financial advisor agent
46const advisor = new FinancialAdvisorAgent({
47  model: alignedModel,
48  name: 'InvestmentAssistant',
49  description: 'SEC-compliant financial information assistant'
50});
51
52// The agent will now maintain compliance with financial regulations
53// when providing information to users

1import { RuntimeValidator } from '@akioudai/safety-sdk';
2
3// Initialize runtime validator for continuous monitoring
4const validator = new RuntimeValidator({
5  apiKey: process.env.AKIOUDAI_API_KEY,
6  checkpoints: ['input', 'processing', 'output'],
7  metrics: ['consistency', 'safety', 'performance'],
8  threshold: 0.9
9});
10
11// Create a monitoring wrapper for an AI service
12function createMonitoredService(aiService) {
13  return {
14    async process(input, options) {
15      // Create execution context for validation
16      const execution = {
17        id: generateUniqueId(),
18        startTime: Date.now(),
19        input: input,
20        model: aiService.modelInfo,
21        parameters: options,
22        output: null
23      };
24      
25      try {
26        // Start validation
27        validator.startValidation(execution);
28        
29        // Process input with safe default parameters
30        const safeOptions = validator.getSafeParameters(options);
31        let output = await aiService.process(input, safeOptions);
32        
33        // Add output to execution context
34        execution.output = output;
35        execution.endTime = Date.now();
36        
37        // Validate output
38        const validationResult = await validator.validate(execution, {
39          realtime: true,
40          callbacks: {
41            onViolation: (issue) => {
42              console.warn('Validation issue detected:', issue);
43              logIssue(execution.id, issue);
44            }
45          }
46        });
47        
48        // Handle validation results
49        if (!validationResult.valid) {
50          // Apply automatic corrections if possible
51          if (validationResult.corrections) {
52            output = validationResult.corrections.output || output;
53          }
54          
55          // For critical issues, block output
56          if (validationResult.critical) {
57            throw new Error('Critical validation failure: ' + 
58              validationResult.issues.map(i => i.description).join(', '));
59          }
60        }
61        
62        return {
63          result: output,
64          validationStatus: validationResult.valid ? 'passed' : 'issues',
65          metrics: validationResult.metrics
66        };
67      } catch (error) {
68        // Log error and execution context
69        execution.error = error.message;
70        execution.endTime = Date.now();
71        
72        // Complete validation with error
73        validator.completeValidation(execution, 'error');
74        
75        throw error;
76      }
77    }
78  };
79}
80
81// Example usage
82const secureImageGenerator = createMonitoredService(imageGenerationService);
83const result = await secureImageGenerator.process(
84  "Generate an image of a peaceful mountain landscape",
85  { width: 1024, height: 768, style: "photorealistic" }
86);

1import { ComplianceFramework } from '@akioudai/safety-sdk';
2
3// Initialize EU AI Act compliance framework
4const euAiAct = new ComplianceFramework({
5  apiKey: process.env.AKIOUDAI_API_KEY,
6  framework: 'eu_ai_act',
7  riskCategory: 'high', // 'minimal', 'limited', 'high', 'unacceptable'
8  domain: 'healthcare'  // Specify the industry domain
9});
10
11// Set up documentation requirements for high-risk systems
12const documentationGenerator = euAiAct.createDocumentationGenerator({
13  system: {
14    name: 'DiagnosisAssistant',
15    version: '1.0.4',
16    purpose: 'Supporting clinical diagnosis by analyzing patient data',
17    capabilities: ['data analysis', 'pattern recognition', 'decision support'],
18    limitations: ['not a replacement for professional judgment', 
19                 'requires human oversight']
20  },
21  organization: {
22    name: 'Medical AI Solutions',
23    contact: 'compliance@medicalai.example',
24    address: '123 Innovation Drive, Brussels, Belgium'
25  }
26});
27
28// Generate required technical documentation
29const technicalDocs = await documentationGenerator.generateTechnicalDocumentation();
30console.log('Technical Documentation Sections:', Object.keys(technicalDocs));
31
32// Perform risk assessment
33const riskAssessment = await euAiAct.performRiskAssessment({
34  dataDescription: 'Patient health records, medical imaging, lab results',
35  dataSources: ['electronic health records', 'radiology information systems'],
36  dataRetention: '5 years in compliance with medical records requirements',
37  securityMeasures: ['end-to-end encryption', 'access controls', 'audit logs']
38});
39
40// Output risk findings and mitigations
41for (const risk of riskAssessment.risks) {
42  console.log(`Risk: ${risk.description}`);
43  console.log(`Severity: ${risk.severity}`);
44  console.log(`Mitigations: ${risk.mitigations.join(', ')}`);
45  console.log('---');
46}
47
48// Create conformity assessment checklist
49const conformityChecklist = await euAiAct.generateConformityChecklist();
50console.log(`Completed: ${conformityChecklist.completedItems.length} of ${conformityChecklist.totalItems}`);
51
52// Missing requirements
53if (conformityChecklist.missingItems.length > 0) {
54  console.log('Missing requirements:');
55  for (const item of conformityChecklist.missingItems) {
56    console.log(`- ${item.requirement}: ${item.description}`);
57  }
58}
59
60// Generate official declaration of conformity when ready
61if (conformityChecklist.readyForDeclaration) {
62  const declaration = await euAiAct.generateDeclarationOfConformity();
63  fs.writeFileSync('eu_ai_act_declaration.pdf', declaration.pdf);
64  console.log('Declaration of Conformity generated successfully');
65}