Production-Ready
AI Safety

Integrate Tractatus framework into your AI systems with practical guides, code examples, and battle-tested patterns for real-world deployment.

Quick Start Guide View Documentation
DOCUMENTATION 📚

Deployment Architecture Guide

Comprehensive conceptual guide to deploying Tractatus-based systems. Understand architecture patterns, security best practices, and integration strategies for research and educational purposes.

Framework architecture overview
Deployment patterns (dev/prod)
Security best practices
Troubleshooting guidance
View Deployment Guide

For production implementation support, contact john.stroh.nz@pm.me

Guide Contents:

  • â–¸
    Architecture Overview

    4-layer system design

  • â–¸
    Deployment Patterns

    Dev, single-server, containerized

  • â–¸
    Security Best Practices

    Network, app, operational security

  • â–¸
    Configuration Guide

    Environment variables, indexes

  • â–¸
    Monitoring & Scaling

    Metrics, alerts, scaling strategies

  • â–¸
    Troubleshooting

    Common issues & solutions

System Architecture

Understanding how Tractatus integrates with Claude Code to provide robust AI governance

Tractatus Framework Architecture showing four layers: API & Web Interface, Tractatus Governance Layer with 6 services, MongoDB Persistence, and Claude Code Runtime Environment
Download SVG Download PNG (High-Res) Technical Documentation PDF
Layer 4

API & Web Interface

  • • Demo endpoints
  • • Admin dashboard
  • • Documentation
  • • Blog system
Layer 3

Tractatus Governance

  • • BoundaryEnforcer
  • • InstructionPersistenceClassifier
  • • CrossReferenceValidator
  • • ContextPressureMonitor
  • • MetacognitiveVerifier
  • • PluralisticDeliberationOrchestrator
Layer 2

MongoDB Persistence

  • • governance_rules
  • • audit_logs
  • • session_state
  • • instruction_history
Layer 1

Claude Code Runtime

  • • Base LLM environment
  • • Session management
  • • Tool access
  • • Context window (200k)

Key Integration Points

1

Pre-Action Checks

All actions validated against governance rules before execution

2

Instruction Persistence

User instructions classified and stored for cross-reference validation

3

Comprehensive Audit Trail

Every governance action logged for compliance and analysis

Integration Approaches

Full Stack

Complete framework integration for new AI-powered applications. All six services active with persistent instruction storage.

  • Instruction classification & storage
  • Cross-reference validation
  • Boundary enforcement
  • Context pressure monitoring
Best for: New projects, greenfield AI applications

Middleware Layer

Add Tractatus validation as middleware in existing AI pipelines. Non-invasive integration with gradual rollout support.

  • Drop-in Express/Koa middleware
  • Monitor mode (log only)
  • Gradual enforcement rollout
  • Compatible with existing auth
Best for: Existing production AI systems

Selective Components

Use individual Tractatus services à la carte. Mix and match components based on your specific safety requirements.

  • Standalone pressure monitoring
  • Boundary checks only
  • Classification without storage
  • Custom component combinations
Best for: Specific safety requirements

Quick Start Guide

1

Installation

npm install @tractatus/framework
# or
yarn add @tractatus/framework

Install the framework package and its dependencies (MongoDB for instruction storage).

2

Initialize Services

const { TractatusFramework } = require('@tractatus/framework');

const tractatus = new TractatusFramework({
  mongoUri: process.env.MONGODB_URI,
  verbosity: 'SUMMARY', // or 'VERBOSE', 'SILENT'
  components: {
    classifier: true,
    validator: true,
    boundary: true,
    pressure: true,
    metacognitive: 'selective'
  }
});

await tractatus.initialize();

Configure and initialize the framework with your preferred settings.

3

Classify Instructions

const instruction = "Always use MongoDB on port 27017";

const classification = await tractatus.classify(instruction);
// {
//   quadrant: 'SYSTEM',
//   persistence: 'HIGH',
//   temporal_scope: 'PROJECT',
//   verification_required: 'MANDATORY',
//   explicitness: 0.85
// }

if (classification.explicitness >= 0.6) {
  await tractatus.store(instruction, classification);
}

Classify user instructions and store those that meet explicitness threshold.

4

Validate Actions

// User instructed: "Check MongoDB at port 27027"
// But AI about to use port 27017 (pattern recognition bias)

const action = {
  type: 'db_config',
  parameters: { port: 27017 } // Pattern override!
};

const validation = await tractatus.validate(action);

if (validation.status === 'REJECTED') {
  // "Port 27017 conflicts with instruction: use port 27027"
  console.error(`Validation failed: ${validation.reason}`);
  console.log(`Using instructed port: ${validation.correct_parameters.port}`);
  // Use correct port 27027
} else {
  executeAction(action);
}

Validate AI actions against stored instructions before execution.

5

Enforce Boundaries

// Check if decision crosses Tractatus boundary
const decision = {
  domain: 'values',
  description: 'Change privacy policy to enable analytics'
};

const boundary = await tractatus.checkBoundary(decision);

if (!boundary.allowed) {
  // Requires human decision
  await notifyHuman({
    decision,
    reason: boundary.reason,
    alternatives: boundary.ai_can_provide
  });
}

Enforce boundaries: AI cannot make values decisions without human approval.

Integration Patterns

Express Middleware

app.use(tractatus.middleware({
  mode: 'enforce', // or 'monitor'
  onViolation: async (req, res, violation) => {
    await logViolation(violation);
    res.status(403).json({
      error: 'Tractatus boundary violation',
      reason: violation.reason
    });
  }
}));

Content Moderation

async function moderateContent(content) {
  const decision = {
    domain: 'values',
    action: 'auto_moderate',
    content
  };

  const check = await tractatus.checkBoundary(decision);

  if (!check.allowed) {
    return { action: 'human_review', alternatives: check.ai_can_provide };
  }
}

Pressure Monitoring

const pressure = await tractatus.checkPressure({
  tokens: 150000,
  messages: 45,
  errors: 2
});

if (pressure.level === 'CRITICAL') {
  await suggestHandoff(pressure.recommendations);
} else if (pressure.level === 'HIGH') {
  await increaseVerification();
}

Custom Classification

const customClassifier = {
  patterns: {
    CRITICAL: /security|auth|password/i,
    HIGH: /database|config|api/i
  },

  classify(text) {
    for (const [level, pattern] of Object.entries(this.patterns)) {
      if (pattern.test(text)) return level;
    }
    return 'MEDIUM';
  }
};

Implementation Resources

Technical Documentation

Examples

Support

Get help with implementation, integration, and troubleshooting.

  • • GitHub Issues & Discussions
  • • Implementation consulting
  • • Community Slack channel

Ready to Implement?

Join organizations building safer AI systems with architectural guarantees.

View Full Documentation Research Background →