DaxBot

Enterprise-Grade Self-Learning AI Assistant with Military-Strength Security

Live Demo: https://daxbot-875130704813.us-central1.run.app

Table of Contents

• Why DaxBot?
• Comparison
• Requirements
• Quick Start
• Configuration
• Channel Integrations
• Template Library
• API Usage
• Security
• LLM Providers
• TypeScript
• Events & Hooks
• Streaming
• Migration
• Troubleshooting
• Development

DaxBot is a next-generation personal AI assistant powered by RuVector's WASM vector operations. It addresses critical security gaps found in Clawdbot while delivering 150x faster performance, self-learning neural architecture, and enterprise-grade multi-tenancy.

Why DaxBot Over Clawdbot?

Clawdbot lacks essential security protections that are mandatory for production AI deployments:

• No prompt injection defense - Clawdbot is vulnerable to adversarial prompts
• No jailbreak detection - Users can bypass system instructions
• No PII protection - Sensitive data leakage risk
• No input sanitization - Control character and unicode attacks possible
• Single-tenant only - No enterprise data isolation

DaxBot solves all of these with a 6-layer security architecture and AIDefence integration.

DaxBot vs Clawdbot Comparison

Performance Benchmarks

Features

• Self-Learning: SONA adaptive learning with trajectory tracking and pattern extraction
• WASM Embeddings: High-performance vector operations using RuVector WASM bindings
• Vector Memory: HNSW-indexed semantic memory with 150x-12,500x faster search
• Multi-Platform: Slack, Discord, webhook, REST API, and CLI interfaces
• Extensible Skills: Plugin architecture for custom capabilities with hot-reload
• Multi-Tenancy: Enterprise-ready with PostgreSQL row-level security
• Background Workers: 12 specialized worker types via agentic-flow
• LLM Routing: Intelligent 3-tier routing for optimal cost/performance

Requirements

• Node.js: 18.0.0 or higher
• npm: 9.0.0 or higher
• API Key: OpenRouter (recommended) or Anthropic

Quick Start

Install via curl (Recommended)

# Basic install
curl -fsSL https://raw.githubusercontent.com/ruvnet/ruvector/main/npm/packages/daxbot/scripts/install.sh | bash

# Install with interactive wizard
DAXBOT_WIZARD=true curl -fsSL https://raw.githubusercontent.com/ruvnet/ruvector/main/npm/packages/daxbot/scripts/install.sh | bash

# Install specific version
DAXBOT_VERSION=0.1.3 curl -fsSL https://raw.githubusercontent.com/ruvnet/ruvector/main/npm/packages/daxbot/scripts/install.sh | bash

# Install and deploy to Cloud Run
DAXBOT_DEPLOY=cloudrun curl -fsSL https://raw.githubusercontent.com/ruvnet/ruvector/main/npm/packages/daxbot/scripts/install.sh | bash

# Install with Slack channel dependencies
DAXBOT_CHANNEL=slack curl -fsSL https://raw.githubusercontent.com/ruvnet/ruvector/main/npm/packages/daxbot/scripts/install.sh | bash

Install Options (Environment Variables)

Install via npm/npx

# Run directly (no install)
npx daxbot start

# Install globally
npm install -g daxbot
daxbot start

# Install locally
npm install daxbot
npx daxbot start

Configuration

Environment Variables

# LLM Provider (required - choose one)
# Option 1: OpenRouter (RECOMMENDED - access to Gemini 2.5, Claude, GPT, etc.)
export OPENROUTER_API_KEY=sk-or-xxx

# Option 2: Anthropic Direct
export ANTHROPIC_API_KEY=sk-ant-xxx

# Slack Integration (optional)
export SLACK_BOT_TOKEN=xoxb-xxx
export SLACK_SIGNING_SECRET=xxx
export SLACK_APP_TOKEN=xapp-xxx

# Discord Integration (optional)
export DISCORD_TOKEN=xxx
export DISCORD_CLIENT_ID=xxx

# Server Configuration
export DAXBOT_PORT=3000
export DAXBOT_LOG_LEVEL=info

Configuration File

Create daxbot.config.json:

{
  "name": "my-daxbot",
  "api": {
    "enabled": true,
    "port": 3000,
    "host": "0.0.0.0"
  },
  "storage": {
    "type": "sqlite",
    "path": "./data/daxbot.db"
  },
  "memory": {
    "dimensions": 384,
    "maxVectors": 100000,
    "indexType": "hnsw"
  },
  "skills": {
    "enabled": ["search", "summarize", "code", "memory"]
  },
  "slack": {
    "enabled": true,
    "socketMode": true
  }
}

CLI Commands

# Initialize in current directory
daxbot init

# Start the bot server
daxbot start [--port 3000] [--debug]

# Start with a specific channel
daxbot start --channel slack
daxbot start --channel discord
daxbot start --channel telegram

# Check status
daxbot status

# Manage skills
daxbot skills list
daxbot skills add <name>

# Channel setup help
daxbot channels list
daxbot channels setup slack
daxbot channels setup discord
daxbot channels setup telegram

# Template library
daxbot templates list
daxbot templates info <template-id>
daxbot deploy <template-id>

# Run diagnostics
daxbot doctor

# Show configuration
daxbot config --show

Channel Integrations

DaxBot supports multiple messaging platforms. Use daxbot channels setup <platform> for interactive setup guides.

Slack Integration

Step 1: Create a Slack App

1. Go to https://api.slack.com/apps
2. Click "Create New App" → "From Scratch"
3. Name your app and select your workspace

Step 2: Configure Bot Permissions Navigate to OAuth & Permissions and add these Bot Token Scopes:

• app_mentions:read - Receive @mentions
• chat:write - Send messages
• channels:history - Read channel messages
• im:history - Read direct messages
• reactions:write - Add reactions
• files:read - Access shared files

Step 3: Enable Socket Mode

1. Go to Socket Mode → Enable
2. Create an App-Level Token with connections:write scope
3. Save the xapp-... token

Step 4: Install & Get Tokens

1. Go to Install App → Install to Workspace
2. Copy the Bot User OAuth Token (xoxb-...)
3. Copy the Signing Secret from Basic Information

Step 5: Configure Environment

export SLACK_BOT_TOKEN="xoxb-your-bot-token"
export SLACK_SIGNING_SECRET="your-signing-secret"
export SLACK_APP_TOKEN="xapp-your-app-token"

# Start with Slack
daxbot start --channel slack

Step 6: Enable Events (Optional) For real-time events without Socket Mode:

1. Go to Event Subscriptions → Enable
2. Add Request URL: https://your-daxbot.run.app/slack/events
3. Subscribe to bot events: message.channels, message.im, app_mention

Discord Integration

Step 1: Create a Discord Application

1. Go to https://discord.com/developers/applications
2. Click "New Application" and name it

Step 2: Create a Bot

1. Go to Bot section → Add Bot
2. Enable Privileged Gateway Intents:
   • ✅ Message Content Intent
   • ✅ Server Members Intent
3. Copy the Bot Token (click "Reset Token" if needed)

Step 3: Get Application IDs

1. Copy Application ID from General Information
2. Right-click your server → Copy Server ID (for guild-specific commands)

Step 4: Invite Bot to Server

1. Go to OAuth2 → URL Generator
2. Select scopes: bot, applications.commands
3. Select permissions: Send Messages, Read Message History, Add Reactions, Use Slash Commands
4. Open the generated URL to invite the bot

Step 5: Configure Environment

export DISCORD_TOKEN="your-bot-token"
export DISCORD_CLIENT_ID="your-application-id"
export DISCORD_GUILD_ID="your-server-id"  # Optional, for testing

# Start with Discord
daxbot start --channel discord

Telegram Integration

Step 1: Create a Bot with BotFather

1. Open Telegram and search for @BotFather
2. Send /newbot command
3. Follow prompts to name your bot
4. Copy the HTTP API token (format: 123456789:ABC-DEF...)

Step 2: Configure Environment

export TELEGRAM_BOT_TOKEN="your-bot-token"

# Start with Telegram
daxbot start --channel telegram

Step 3: Test Your Bot

1. Search for your bot by username in Telegram
2. Start a chat and send /start
3. Send messages to interact with DaxBot

Production: Webhook Mode For production deployments (Cloud Run, etc.), use webhook mode:

export TELEGRAM_BOT_TOKEN="your-bot-token"
export TELEGRAM_WEBHOOK_URL="https://your-daxbot.run.app/telegram/webhook"

Multi-Channel Configuration

Run DaxBot with multiple channels simultaneously:

{
  "name": "my-daxbot",
  "channels": {
    "slack": {
      "enabled": true,
      "token": "${SLACK_BOT_TOKEN}",
      "signingSecret": "${SLACK_SIGNING_SECRET}",
      "appToken": "${SLACK_APP_TOKEN}"
    },
    "discord": {
      "enabled": true,
      "token": "${DISCORD_TOKEN}",
      "clientId": "${DISCORD_CLIENT_ID}"
    },
    "telegram": {
      "enabled": true,
      "token": "${TELEGRAM_BOT_TOKEN}"
    }
  }
}

Install optional dependencies:

npm install @slack/bolt @slack/web-api discord.js telegraf

Cloud Run Channel Setup

For Google Cloud Run deployments:

# Slack
gcloud run services update daxbot --set-env-vars="\
SLACK_BOT_TOKEN=xoxb-...,\
SLACK_SIGNING_SECRET=...,\
SLACK_APP_TOKEN=xapp-..."

# Discord
gcloud run services update daxbot --set-env-vars="\
DISCORD_TOKEN=...,\
DISCORD_CLIENT_ID=...,\
DISCORD_GUILD_ID=..."

# Telegram (webhook mode recommended)
gcloud run services update daxbot --set-env-vars="\
TELEGRAM_BOT_TOKEN=...,\
TELEGRAM_WEBHOOK_URL=https://daxbot-xxx.run.app/telegram/webhook"

Template Library

DaxBot includes pre-built templates for deploying long-running agent patterns.

List Available Templates

daxbot templates list
daxbot templates list --category advanced

Available Templates

Deploy a Template

# View template details
daxbot templates info hive-mind

# Deploy a template
daxbot deploy code-reviewer --repo ./my-project

# Deploy with options
daxbot deploy feature-swarm --name "auth-feature" --model google/gemini-2.0-flash-001

# Dry run (preview without executing)
daxbot deploy hive-mind --dry-run

Template Examples

# Code review with security scanning
daxbot deploy code-reviewer --repo ./my-project

# Documentation generation
daxbot deploy doc-generator --output ./docs

# Test suite generation with 80% coverage target
daxbot deploy test-generator --coverage 80

# Feature development with coordinated swarm
daxbot deploy feature-swarm --feature "Add user authentication"

# Research across multiple sources
daxbot deploy research-swarm --topic "vector databases"

# Hive-mind for complex objectives
daxbot deploy hive-mind --objective "Build complete REST API"

# Byzantine validation for critical operations
daxbot deploy byzantine-validator --quorum 4

API Usage

REST API Endpoints

Quick Start

# Check health
curl https://your-daxbot.run.app/health

# List available models
curl https://your-daxbot.run.app/api/models

# Create a session
curl -X POST https://your-daxbot.run.app/api/sessions \
  -H "Content-Type: application/json" \
  -d '{"agentId": "default-agent"}'

# Chat (with automatic AIDefence protection)
curl -X POST https://your-daxbot.run.app/api/sessions/{id}/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "Hello, DaxBot!"}'

Programmatic Usage

import { DaxBot, createDaxBot } from '@ruvector/daxbot';

// Create bot instance
const bot = createDaxBot({
  config: {
    llm: {
      provider: 'anthropic',
      apiKey: process.env.ANTHROPIC_API_KEY,
    },
    memory: {
      dimensions: 384,
      maxVectors: 100000,
    },
  },
});

// Start the bot
await bot.start();

// Spawn an agent
const agent = await bot.spawnAgent({
  id: 'assistant',
  name: 'My Assistant',
});

// Create a session
const session = await bot.createSession(agent.id, {
  userId: 'user-123',
  platform: 'api',
});

// Chat
const response = await bot.chat(session.id, 'What can you help me with?');
console.log(response.content);

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                           DaxBot                                 │
├─────────────────────────────────────────────────────────────────┤
│  REST API │ GraphQL │ Slack Adapter │ Discord │ Webhooks       │
├─────────────────────────────────────────────────────────────────┤
│                     Core Application Layer                       │
│  AgentManager │ SessionStore │ SkillRegistry │ MemoryManager    │
├─────────────────────────────────────────────────────────────────┤
│                      Learning Layer                              │
│  SONA Trainer │ Pattern Extractor │ Trajectory Store │ EWC++    │
├─────────────────────────────────────────────────────────────────┤
│                    Infrastructure Layer                          │
│  RuVector WASM │ PostgreSQL │ RuvLLM │ agentic-flow Workers     │
└─────────────────────────────────────────────────────────────────┘

Intelligent LLM Routing (3-Tier)

Benefits: 75% cost reduction, 352x faster for Tier 1 tasks.

Security Architecture (6 Layers) - Why This Matters

Clawdbot's security model is fundamentally insufficient for production AI:

DaxBot's Defense-in-Depth Architecture:

┌─────────────────────────────────────────────────────────────────┐
│ Layer 1: Transport (TLS 1.3, HSTS, cert pinning)               │
│ Layer 2: Authentication (JWT RS256, OAuth 2.0, rate limiting)  │
│ Layer 3: Authorization (RBAC, claims, tenant isolation)        │
│ Layer 4: Data Protection (AES-256-GCM, key rotation)           │
│ Layer 5: AIDefence (prompt injection, jailbreak, PII)          │
│ Layer 6: WASM Sandbox (memory isolation, resource limits)      │
└─────────────────────────────────────────────────────────────────┘

Compliance Ready: GDPR, SOC 2, HIPAA (configurable).

AI Defense (aidefence Integration) - Critical for Production

Every production AI system needs adversarial defense. Clawdbot has none. DaxBot integrates aidefence for military-grade protection.

Threat Detection (<10ms latency)

• Prompt Injection Detection - 50+ injection pattern signatures
• Jailbreak Prevention - DAN, bypass, unlimited mode, roleplay attacks
• PII Protection - Email, phone, SSN, credit cards, API keys, IP addresses
• Unicode Normalization - Homoglyph and encoding attack prevention
• Behavioral Analysis - User baseline deviation detection
• Response Validation - Prevents LLM from leaking injected content
• Audit Logging - Full threat tracking for compliance

Usage

import { createAIDefenceGuard, createAIDefenceMiddleware } from '@ruvector/daxbot';

// Create guard
const guard = createAIDefenceGuard({
  detectPromptInjection: true,
  detectJailbreak: true,
  detectPII: true,
  blockThreshold: 'medium',
});

// Analyze input
const result = await guard.analyze(userInput);
if (!result.safe) {
  console.log('Threats:', result.threats);
  const safeInput = result.sanitizedInput;
}

// Or use middleware
const middleware = createAIDefenceMiddleware();
const { allowed, sanitizedInput } = await middleware.validateInput(input);

Threat Detection

See ADR-014: AIDefence Integration for details.

Plugin System

DaxBot includes an extensible plugin system inspired by claude-flow's IPFS-based registry.

Features

• Plugin Discovery: Auto-load plugins from ./plugins directory
• Lifecycle Management: Install, enable, disable, unload plugins
• Hot-Reload: Dynamic plugin loading without restart
• Sandboxed Execution: Permission-based access control
• IPFS Registry: Optional decentralized plugin distribution

Usage

import { createPluginManager } from '@ruvector/daxbot';

// Create and initialize plugin manager
const plugins = createPluginManager({
  pluginsDir: './plugins',
  autoLoad: true,
});
await plugins.initialize();

// List plugins and skills
console.log(plugins.listPlugins());
const skills = plugins.getPluginSkills();

Plugin Permissions

Background Workers

Skills

Built-in Skills

Self-Learning Pipeline

┌─────────────────────────────────────────────────────────────────┐
│  User Query ──► Agent Response ──► Outcome ──► Pattern Store    │
│       │              │               │              │           │
│       ▼              ▼               ▼              ▼           │
│   Embedding     Action Log       Reward Score   Neural Update   │
│                                                                 │
│  SONA 4-Step: RETRIEVE → JUDGE → DISTILL → CONSOLIDATE         │
└─────────────────────────────────────────────────────────────────┘

Custom Skills

Create custom skills in the skills/ directory:

// skills/my-skill.ts
import { defineSkill } from '@ruvector/daxbot';

export default defineSkill({
  name: 'my-skill',
  description: 'Custom skill description',
  inputs: [
    { name: 'query', type: 'string', required: true }
  ],
  async execute(params, context) {
    return {
      success: true,
      data: `Processed: ${params.query}`,
    };
  },
});

Memory System

DaxBot uses HNSW-indexed vector memory for fast semantic search:

import { MemoryManager, createWasmEmbedder } from '@ruvector/daxbot/learning';

const embedder = createWasmEmbedder({ dimensions: 384 });
const memory = new MemoryManager({
  config: { dimensions: 384, maxVectors: 100000, indexType: 'hnsw' },
  embedder,
});

// Store a memory
await memory.store('Important information', {
  source: 'user',
  tags: ['important'],
  importance: 0.9,
});

// Search memories
const results = await memory.search('find important info', {
  topK: 5,
  threshold: 0.7,
});

Deployment

DaxBot supports multiple deployment options from local development to enterprise cloud.

Quick Deploy Options

Docker

# docker-compose.yml
version: '3.8'
services:
  daxbot:
    image: ruvector/daxbot:latest
    ports:
      - "3000:3000"
    environment:
      - OPENROUTER_API_KEY=${OPENROUTER_API_KEY}
      - SLACK_BOT_TOKEN=${SLACK_BOT_TOKEN}
      - SLACK_SIGNING_SECRET=${SLACK_SIGNING_SECRET}
      - SLACK_APP_TOKEN=${SLACK_APP_TOKEN}
      - DISCORD_TOKEN=${DISCORD_TOKEN}
      - TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN}
    volumes:
      - ./data:/app/data
      - ./skills:/app/skills

Docker with Webhooks

# docker-compose.yml with webhook configuration
version: '3.8'
services:
  daxbot:
    image: ruvector/daxbot:latest
    ports:
      - "3000:3000"
    environment:
      - OPENROUTER_API_KEY=${OPENROUTER_API_KEY}
      # Outbound webhooks
      - WEBHOOK_URL=https://your-service.com/callback
      - WEBHOOK_SECRET=your-shared-secret
      # Inbound webhook auth
      - WEBHOOK_AUTH_TOKEN=your-auth-token
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

Google Cloud Deployment

DaxBot includes cost-optimized Google Cloud Platform deployment (~$15-20/month for low traffic).

Quick Deploy

# Set environment variables
export ANTHROPIC_API_KEY="sk-ant-..."
export PROJECT_ID="my-gcp-project"

# Deploy with script
./deploy/gcp/deploy.sh --project-id $PROJECT_ID

Terraform (Infrastructure as Code)

cd deploy/gcp/terraform
terraform init
terraform apply \
  -var="project_id=my-project" \
  -var="anthropic_api_key=$ANTHROPIC_API_KEY"

Cost Breakdown

Features

• Serverless: Scale to zero when not in use
• Managed Database: Cloud SQL PostgreSQL with automatic backups
• Secure Secrets: Secret Manager for API keys
• CI/CD: Cloud Build pipeline included
• Terraform: Full infrastructure as code support

See ADR-013: GCP Deployment for architecture details.

gcloud CLI Integration

DaxBot includes native gcloud CLI integration for Cloud Run deployments.

Prerequisites:

# Install gcloud CLI
curl https://sdk.cloud.google.com | bash

# Authenticate
gcloud auth login

# Set project
gcloud config set project YOUR_PROJECT_ID

Deploy with CLI:

# Interactive deployment wizard
daxbot deploy-cloud wizard

# Deploy to Cloud Run
daxbot deploy-cloud cloudrun --project my-project --region us-central1

# Deploy with environment file
daxbot deploy-cloud cloudrun --env-file .env

# Deploy to Docker
daxbot deploy-cloud docker --port 3000

# Deploy to Kubernetes
daxbot deploy-cloud k8s --namespace production --replicas 3

# Check deployment status
daxbot deploy-cloud status

CLI Options:

Deploy with Channel Webhooks (Cloud Run)

Complete Cloud Run deployment with all channel webhooks:

# Build and deploy
gcloud run deploy daxbot \
  --source . \
  --platform managed \
  --region us-central1 \
  --allow-unauthenticated \
  --set-env-vars="\
OPENROUTER_API_KEY=${OPENROUTER_API_KEY},\
DEFAULT_MODEL=google/gemini-2.0-flash-001,\
SLACK_BOT_TOKEN=${SLACK_BOT_TOKEN},\
SLACK_SIGNING_SECRET=${SLACK_SIGNING_SECRET},\
TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN},\
TELEGRAM_WEBHOOK_URL=https://daxbot-xxx.run.app/telegram/webhook,\
DISCORD_TOKEN=${DISCORD_TOKEN},\
DISCORD_CLIENT_ID=${DISCORD_CLIENT_ID}"

Kubernetes Deployment

# k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: daxbot
spec:
  replicas: 2
  selector:
    matchLabels:
      app: daxbot
  template:
    metadata:
      labels:
        app: daxbot
    spec:
      containers:
      - name: daxbot
        image: ruvector/daxbot:latest
        ports:
        - containerPort: 3000
        envFrom:
        - secretRef:
            name: daxbot-secrets
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 10
          periodSeconds: 30
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: daxbot
spec:
  selector:
    app: daxbot
  ports:
  - port: 80
    targetPort: 3000
  type: LoadBalancer

Webhook Configuration

Inbound Webhooks

DaxBot exposes webhook endpoints for receiving messages from external services.

Webhook Security

# Set webhook authentication
export WEBHOOK_SECRET="your-shared-secret"
export WEBHOOK_AUTH_TOKEN="bearer-token-for-inbound"

Inbound requests are validated using:

• X-Webhook-Secret header for HMAC signature verification
• Authorization header with Bearer token
• Request body signature validation

Outbound Webhooks

Configure DaxBot to send responses and events to your services:

{
  "webhooks": {
    "outbound": {
      "url": "https://your-service.com/daxbot-callback",
      "secret": "shared-secret-for-signing",
      "events": ["message", "agent.spawn", "session.create", "error"],
      "retries": 3,
      "timeout": 30000,
      "headers": {
        "X-Custom-Header": "value"
      }
    }
  }
}

Webhook Event Types

Example: Custom Integration

// Your webhook receiver
app.post('/daxbot-callback', (req, res) => {
  // Verify signature
  const signature = req.headers['x-webhook-signature'];
  const isValid = verifyHmac(req.body, signature, WEBHOOK_SECRET);

  if (!isValid) {
    return res.status(401).send('Invalid signature');
  }

  const { event, data } = req.body;

  switch (event) {
    case 'message.response':
      // Forward to your chat system
      sendToChat(data.sessionId, data.content);
      break;
    case 'security.threat':
      // Alert security team
      alertSecurity(data);
      break;
  }

  res.status(200).send('OK');
});

CLI Webhook Commands

# List configured webhooks
daxbot webhooks list

# Test a webhook endpoint
daxbot webhooks test https://your-service.com/callback

# Test with custom payload
daxbot webhooks test https://your-service.com/callback \
  --payload '{"test": true, "message": "Hello"}'

# Show channel-specific setup
daxbot channels setup webhook

LLM Providers - Gemini 2.5 Default

DaxBot supports 12+ models with Gemini 2.5 Pro as the recommended default for optimal cost/performance.

Available Models (via REST API)

curl https://your-daxbot.run.app/api/models

OpenRouter (Default - 200+ Models)

import { createOpenRouterProvider } from '@ruvector/daxbot';

// Gemini 2.5 Pro (recommended)
const provider = createOpenRouterProvider({
  apiKey: process.env.OPENROUTER_API_KEY,
  model: 'google/gemini-2.5-pro-preview-05-06',
});

Anthropic (Direct)

import { createAnthropicProvider } from '@ruvector/daxbot';

const provider = createAnthropicProvider({
  apiKey: process.env.ANTHROPIC_API_KEY,
  model: 'claude-3-5-sonnet-20241022',
});

See ADR-012: LLM Providers for details.

TypeScript Support

DaxBot is written in TypeScript and provides full type definitions:

import type {
  DaxBot,
  DaxBotOptions,
  Agent,
  AgentConfig,
  Session,
  Message,
  BotConfig,
} from '@ruvector/daxbot';

// Full IntelliSense support
const bot = createDaxBot({
  config: {
    name: 'MyBot',
    llm: { provider: 'anthropic', apiKey: '...' },
  },
});

Events & Hooks

DaxBot emits events for lifecycle and message handling:

import { createDaxBot } from '@ruvector/daxbot';

const bot = createDaxBot();

// Lifecycle events
bot.on('ready', () => console.log('Bot is ready'));
bot.on('shutdown', () => console.log('Bot shutting down'));
bot.on('error', (error) => console.error('Error:', error));

// Agent events
bot.on('agent:spawn', (agent) => console.log('Agent spawned:', agent.id));
bot.on('agent:stop', (agentId) => console.log('Agent stopped:', agentId));

// Session events
bot.on('session:create', (session) => console.log('Session created:', session.id));
bot.on('session:end', (sessionId) => console.log('Session ended:', sessionId));

// Message events
bot.on('message', (message, session) => {
  console.log(`[${message.role}]: ${message.content}`);
});

Streaming Responses

DaxBot supports streaming for real-time responses:

import { createDaxBot } from '@ruvector/daxbot';

const bot = createDaxBot({
  config: {
    llm: {
      provider: 'anthropic',
      apiKey: process.env.ANTHROPIC_API_KEY,
      streaming: true,  // Enable streaming
    },
  },
});

// Streaming is handled automatically in chat responses
const response = await bot.chat(sessionId, 'Tell me a story');

Migration from Clawdbot

DaxBot provides a seamless migration path from Clawdbot:

1. Export Clawdbot Data

# Export your Clawdbot data
clawdbot export --format json > clawdbot-data.json

2. Install DaxBot

npm install -g @ruvector/daxbot

3. Import Data

daxbot import --from-clawdbot clawdbot-data.json

4. Verify Migration

daxbot doctor --verify-migration

Key Differences

Skill Compatibility

All 52 Clawdbot skills are compatible with DaxBot. Simply copy your skills/ directory.

Troubleshooting

Common Issues

LLM not configured

[DaxBot] LLM not configured. Received: "..."

Solution: Set OPENROUTER_API_KEY or ANTHROPIC_API_KEY environment variable.

Agent not found

Error: Agent with ID xxx not found

Solution: Create an agent first with bot.spawnAgent() or use default-agent.

Session expired

Error: Session with ID xxx not found

Solution: Sessions expire after 1 hour by default. Create a new session.

Memory search returns empty

No results found

Solution: Ensure you've stored memories first and the HNSW index is initialized.

Debug Mode

# Enable debug logging
export LOG_LEVEL=debug
daxbot start --debug

Health Check

# Check service health
curl https://your-daxbot.run.app/health

# Run diagnostics
daxbot doctor

Development

# Clone the repository
git clone https://github.com/ruvnet/ruvector.git
cd ruvector/npm/packages/daxbot

# Install dependencies
npm install

# Run in development mode
npm run dev

# Run tests
npm test

# Run tests with coverage
npm run test:coverage

# Type check
npm run typecheck

# Build
npm run build

Dependencies

What's New in v0.1.0

• Gemini 2.5 Pro Support - Default model with state-of-the-art reasoning
• 12+ LLM Models - Gemini, Claude, GPT, Qwen, DeepSeek, Llama
• AIDefence Integration - Military-grade adversarial protection
• 6-Layer Security - Defense-in-depth architecture
• HNSW Vector Search - 150x-12,500x faster than linear search
• SONA Learning - Self-optimizing neural architecture
• Cloud Run Ready - Serverless deployment with scale-to-zero
• Multi-tenancy - PostgreSQL RLS for enterprise isolation

License

MIT License - see LICENSE for details.

Contributing

See CONTRIBUTING.md for contribution guidelines.

Links

• Live Demo: https://daxbot-875130704813.us-central1.run.app
• npm Package: https://www.npmjs.com/package/@ruvector/daxbot
• Repository: https://github.com/ruvnet/ruvector
• Issues: https://github.com/ruvnet/ruvector/issues
• Documentation: https://github.com/ruvnet/ruvector/tree/main/npm/packages/daxbot
• Feature Comparison: docs/FEATURE_COMPARISON.md
• ADR Documents: docs/adr/

Support

• GitHub Issues: https://github.com/ruvnet/ruvector/issues
• Discussions: https://github.com/ruvnet/ruvector/discussions

Made with security in mind by the RuVector Team