AI Enabler Built on Enterprise Data Models

DSiloed is a powerful AI enablement platform built on comprehensive enterprise data models. It provides everything you need to build intelligent, AI-powered applications with rich memory support, advanced chat features, and deep integration with leading AI providers.

Whether you're building customer service bots, intelligent automation systems, or knowledge management platforms, DSiloed gives you enterprise-grade data infrastructure combined with cutting-edge AI capabilities including persistent memory graphs, real-time chat, document processing, and autonomous agents.

This interactive guide will walk you through getting started with DSiloed, setting up AI models, leveraging memory systems, and building powerful AI-enabled enterprise applications.

DSiloed is built on a flexible, enterprise-grade data model designed for extensibility and integration. Here are the key components:

To get started with DSiloed, you need to create a tenant. A tenant is an isolated environment for your application data. Follow these steps to create your first tenant:

After creating your tenant, you'll be directed to the dashboard where you can access all available applications. Here's what you'll find:

DSiloed includes powerful AI capabilities through integration with Large Language Models (LLMs). To enable AI features in your applications, you need to configure LLM models using the LLM Manager application.

This guide will walk you through setting up LLM models from various providers including Anthropic (Claude), OpenAI (GPT), Google (Gemini), xAI (Grok), and local Ollama installations.

DSiloed supports multiple LLM providers. Choose one of the following options based on your needs:

First, you'll need to obtain an API key from Anthropic to access Claude models:

To use OpenAI's GPT models (GPT-3.5, GPT-4), you'll need an OpenAI API key:

To use Google's Gemini models, obtain an API key from Google AI Studio:

To use xAI's Grok models, you'll need an API key from xAI:

Ollama allows you to run LLMs locally on your own hardware, providing privacy and offline capability:

# macOS/Linux
curl -fsSL https://ollama.ai/install.sh | sh

# Windows - Download installer from ollama.ai

# Popular models
ollama pull llama2
ollama pull mistral
ollama pull codellama
ollama pull mixtral

# Check if Ollama is running
ollama list

Once you have your API key (or Ollama installed), use the LLM Manager application to create an LLM Model by selecting from pre-configured model types:

Connect Claude Code to your DSiloed tenant using the Model Context Protocol (MCP) to access all your data, conversations, memories, and platform capabilities directly from your development environment.

{
  "projects": {
    "/home/username/my-project": {
      "mcpServers": {
        "harmoniq": {
          "command": "npx",
          "args": [
            "mcp-remote",
            "https://dev.dsiloed.com/api/v1/mcp",
            "--header",
            "Authorization: Bearer YOUR_JWT_TOKEN_HERE"
          ]
        }
      }
    }
  }
}

{
  "projects": {
    "/Users/john/projects/my-app": {
      "mcpServers": {
        "harmoniq": {
          "command": "npx",
          "args": [
            "mcp-remote",
            "https://www.dsiloed.com/api/v1/mcp",
            "--header",
            "Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ..."
          ]
        }
      }
    }
  }
}

{
  "projects": {
    "/home/username/project-one": {
      "mcpServers": {
        "harmoniq": {
          "command": "npx",
          "args": [
            "mcp-remote",
            "https://dev.dsiloed.com/api/v1/mcp",
            "--header",
            "Authorization: Bearer DEV_TOKEN_HERE"
          ]
        }
      }
    },
    "/home/username/project-two": {
      "mcpServers": {
        "harmoniq": {
          "command": "npx",
          "args": [
            "mcp-remote",
            "https://www.dsiloed.com/api/v1/mcp",
            "--header",
            "Authorization: Bearer PROD_TOKEN_HERE"
          ]
        },
        "other-server": {
          "command": "some-command",
          "args": ["arg1"]
        }
      }
    }
  }
}

"https://dev.dsiloed.com/api/v1/mcp?categories=data,memory"

"https://dev.dsiloed.com/api/v1/mcp?categories=agents"

"https://dev.dsiloed.com/api/v1/mcp?tools=general_crud_tool,store_memory_tool,load_memories_tool"

"https://dev.dsiloed.com/api/v1/mcp?categories=data&tools=store_memory_tool"

{
  "projects": {
    "/home/username/my-project": {
      "mcpServers": {
        "harmoniq": {
          "command": "npx",
          "args": [
            "mcp-remote",
            "https://dev.dsiloed.com/api/v1/mcp?categories=data,memory,agents",
            "--header",
            "Authorization: Bearer YOUR_JWT_TOKEN_HERE"
          ]
        }
      }
    }
  }
}

After configuring your LLM model, you can test it in several ways:

The LLM Memory System provides persistent memory capabilities for AI agents and conversations, enabling long-term learning, pattern recognition, and contextual awareness across sessions. Unlike simple chat history, the memory system uses advanced vector embeddings and graph-based relationships to store and retrieve information semantically.

Memory Types

LLM Memory is configured through the memory_management Configuration. The system requires OpenAI's Text Embedding 3 Small model for vector embeddings, which provides high-quality semantic similarity matching.

Configuration Parameters

Configuration Example

// Step 1: Create OpenAI embedding model in LLM Manager first
// Step 2: Optionally create a classifier model (e.g., GPT-3.5-turbo or GPT-4)
// Step 3: Use internal_identifiers in this configuration

const response = await fetch('/api/v1/configurations', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer ' + token,
    'Tenant-Id': tenantId,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    configuration: {
      internal_identifier: 'memory_management',
      configuration_type_id: 'memory_management',
      configuration_values: {
        // Vector Embeddings (Required for semantic search)
        enable_embeddings: true,
        embedding_model_name: 'openai-embeddings',  // Your embedding LlmModel
        embedding_dimensions: 1536,                  // Fixed - do not change
        embedding_similarity_threshold: 0.7,
        max_embedding_length: 8000,

        // Relationship Classification (Optional but recommended)
        classification_model_name: 'classifier',     // Your classifier LlmModel (null = heuristics only)
        classification_method: 'hybrid',             // 'heuristic', 'llm', or 'hybrid'
        classification_llm_threshold_score: 0.9,     // Similarity threshold for LLM usage
        classification_llm_threshold_importance: 0.8, // Importance threshold for LLM usage
        classification_max_llm_calls_per_consolidation: 50  // Cost control limit
      }
    }
  })
});

# Step 1: Create OpenAI embedding model in LLM Manager first
# Step 2: Optionally create a classifier model (e.g., GPT-3.5-turbo or GPT-4)
# Step 3: Use internal_identifiers in this configuration

# Find your tenant
tenant = Tenant.find_by(enterprise_identifier: 'your-tenant')

# Create or update memory_management configuration
config = Configuration.find_or_initialize_by(
  tenant: tenant,
  internal_identifier: 'memory_management'
)

config.update!(
  configuration_values: {
    # Vector Embeddings (Required for semantic search)
    'enable_embeddings' => true,
    'embedding_model_name' => 'openai-embeddings',  # Your embedding LlmModel
    'embedding_dimensions' => 1536,                  # Fixed - do not change
    'embedding_similarity_threshold' => 0.7,
    'max_embedding_length' => 8000,

    # Relationship Classification (Optional but recommended)
    'classification_model_name' => 'classifier',     # Your classifier LlmModel (nil = heuristics only)
    'classification_method' => 'hybrid',             # 'heuristic', 'llm', or 'hybrid'
    'classification_llm_threshold_score' => 0.9,     # Similarity threshold for LLM usage
    'classification_llm_threshold_importance' => 0.8, # Importance threshold for LLM usage
    'classification_max_llm_calls_per_consolidation' => 50  # Cost control limit
  }
)

Semantic Relationship Classification

When memories are connected, the system automatically classifies the type of relationship between them using intelligent semantic analysis. This creates meaningful knowledge graphs instead of generic "related to" connections.

Available Relationship Types

Automatic Background Processing

Once configured, the memory system runs automatic background jobs to maintain and enhance memory quality:

The memory system integrates seamlessly with AI conversations and agents. Memories are automatically loaded and used to provide context for AI responses.

Common Use Cases

DSiloed includes a powerful, reusable ChatAssistant component that provides AI-powered chat capabilities to any application. The component is framework-independent and features a modern, Discord-like interface with conversation management.

Key Features

The ChatAssistant component supports intelligent @ai mentions that allow users to interact with specific LLM models within conversations.

@AI Mention Syntax

Examples

Basic Setup

// Include the ChatAssistant component
<script src="js/components/ChatAssistant.js?v=1771863622"></script>

// Initialize with your API client
const chatAssistant = new ChatAssistant('YourAppName', {
    apiClient: apiClient,
    title: 'AI Assistant',
    placeholder: 'Ask me anything...',
    contextMessage: 'Assistant has access to your data'
});

// Toggle chat visibility
chatAssistant.toggle();

Vue.js Integration

// In your Vue component
methods: {
    initChatAssistant() {
        this.chatAssistant = new ChatAssistant('MyApp', {
            apiClient: this.apiClient,
            title: 'MyApp Assistant',
            onError: (error) => {
                this.showSnackbar('Chat error: ' + error.message, 'error');
            }
        });
    },
    toggleChat() {
        if (this.chatAssistant) {
            this.chatAssistant.toggle();
        }
    }
},
mounted() {
    this.initChatAssistant();
}

React Integration

// In your React component
import { useEffect, useRef } from 'react';

function MyApp() {
    const chatAssistantRef = useRef(null);
    
    useEffect(() => {
        chatAssistantRef.current = new ChatAssistant('MyApp', {
            apiClient: apiClient,
            title: 'MyApp Assistant'
        });
    }, []);
    
    const toggleChat = () => {
        if (chatAssistantRef.current) {
            chatAssistantRef.current.toggle();
        }
    };
    
    return (
        <button onClick={toggleChat}>Toggle Chat</button>
    );
}

Webhooks allow external systems to send messages directly into conversations without authentication. This enables integration with external applications, chatbots, monitoring systems, and more.

Creating Webhooks

Webhooks can be created through the ChatAssistant Settings interface or via API. Each webhook generates a unique URL that external systems can use to post messages.

Webhook API Endpoint

Example CURL Request

# Send a message via webhook
curl -X POST "https://your-domain.com/api/v1/webhooks/your-webhook-key/publish_message" \
     -H "Content-Type: application/json" \
     -d '{
       "message": "Alert: Server CPU usage is at 85%"
     }'

Advanced Usage with @AI Mentions

# Send a message that triggers AI response
curl -X POST "https://your-domain.com/api/v1/webhooks/your-webhook-key/publish_message" \
     -H "Content-Type: application/json" \
     -d '{
       "message": "@ai Please analyze this error and suggest a solution: Database connection timeout after 30 seconds"
     }'

Creating Webhooks via API

// Create a new webhook for a conversation
const webhookData = {
  webhook: {
    name: "Server Monitoring",
    description: "Webhook for server monitoring alerts",
    related_entity_type: "LlmConversation",
    related_entity_id: conversationId,
    direction: "inbound"
  }
};

const response = await fetch('/api/v1/webhooks', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer ' + token,
    'Tenant-Id': tenantId,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(webhookData)
});

const result = await response.json();
console.log('Webhook URL:', result.webhook.url);

ChatAssistant Configuration

Model Context Protocol (MCP) tools provide a standardized interface for AI models to interact with your DSiloed platform. These tools enable LLMs to perform operations, access data, manage agents, handle communications, and more.

All MCP tools are available through the MCP server and can be used by external applications, AI agents, and LLM conversations. This reference lists all 35+ available MCP tools with their descriptions and use cases.

Tools are organized into categories for easier filtering and discovery. Use these category names with the categories query parameter to load specific tool groups.

Tools for sending emails and managing conversation invitations.

Tools for CRUD operations, schema discovery, and file management.

Tools for creating, managing, and executing autonomous AI agents.

Tools for persistent memory management across AI sessions.

Tools for managing LLM conversations and messaging.

Tools for accessing platform documentation.

Utility and administrative tools for system operations.

Tools for creating, managing, and executing serverless JavaScript functions.

MCP tools can be accessed in multiple ways:

DSiloed provides a comprehensive RESTful API for building applications. All endpoints follow consistent RESTful conventions with JSON responses.

Authentication

Authentication uses JWT (JSON Web Tokens) passed in the Authorization header.

curl -X GET "https://example-model-api.com/api/v1/parties" \
    -H "Authorization: Bearer YOUR_JWT_TOKEN" \
    -H "Tenant-Id: your-tenant-id"

Content Types

All API requests should use JSON for request bodies and accept JSON responses.

-H "Content-Type: application/json" \
-H "Accept: application/json"

Response Format

Responses follow a consistent format with data returned in an object named after the resource.

// Single resource example (e.g., GET /api/v1/users/123)
{
  "success": true,
  "user": {
    "id": 123,
    "description": "John Doe",
    "created_at": "2025-05-01T12:34:56Z",
    "updated_at": "2025-05-02T10:11:12Z"
  }
}

// Multiple resources example (e.g., GET /api/v1/users)
{
  "success": true,
  "total_count": 42,
  "users": [
    {
      "id": 123,
      "description": "John Doe",
      "created_at": "2025-05-01T12:34:56Z"
    },
    {
      "id": 124,
      "description": "Jane Smith",
      "created_at": "2025-05-02T08:15:30Z"
    }
    // ... more users
  ]
}

Error Handling

Errors return a simple format with success set to false and an error message.

{
  "success": false,
  "message": "Invalid Access"
}

The Cross-Tenant User Access system enables controlled user-level access between tenants. Users from one tenant can be granted specific roles and permissions in another tenant, enabling collaboration while maintaining security and data isolation.

Key Features

Step 1: Tenant A requests access for specific users
Step 2: Tenant B accepts the relationship request
Step 3: Tenant B grants SecurityRoles to users from Tenant A
Step 4: Users switch workspaces and access Tenant B's data (within their role permissions)

Dynamic Functions provide a serverless JavaScript execution environment within the DSiloed platform. They allow you to create, manage, and execute custom JavaScript functions that can integrate with external APIs, process data, and automate workflows—all without managing any infrastructure.

Create a dynamic function using the REST API. Functions receive a context object with parameters, configuration, OAuth tokens, and tenant information.

// Create a function via REST API
POST /api/v1/dynamic_functions
Content-Type: application/json

{
  "dynamic_function": {
    "name": "hello_world",
    "description": "A simple greeting function",
    "javascript_code": "return { message: 'Hello, ' + (params.name || 'World') + '!' };",
    "active": true,
    "timeout_seconds": 30
  }
}

Execute the function by ID or name:

// Execute by name
POST /api/v1/dynamic_functions/hello_world/execute
Content-Type: application/json

{
  "params": {
    "name": "DSiloed"
  }
}

// Response:
{
  "success": true,
  "result": { "message": "Hello, DSiloed!" },
  "execution_id": 456,
  "execution_time_ms": 12
}

Functions receive a rich context with access to parameters, configuration, and built-in functions for data access and HTTP requests.

// Available context properties
params                    // Parameters passed when executing
config                    // Function configuration (excluding secrets)
functionId                // Database ID of this function
functionName              // Function name
tenantId                  // Current tenant ID

// OAuth tokens (if connected)
oauth.accessToken         // OAuth access token
oauth.tokenType           // Token type (usually "Bearer")

// Callback context (only in callback executions)
event                     // 'create', 'update', or 'destroy'
model_name                // Model class name (e.g., 'Task')
record_id                 // ID of the affected record
record                    // Full record data
changes                   // Changed attributes (update only)

// Make HTTP requests to external APIs
const response = await fetch('https://api.example.com/data', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${oauth.accessToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ key: 'value' })
});

const data = await response.json();
return { fetched: data };

// Query tenant data
var customers = executeAction('Individual', 'list', {
  filters: { role_type_id: 'customer' },
  limit: 100
});

// Create records
var newContact = executeAction('PhoneNumber', 'create', {
  attributes: {
    party_id: 123,
    phone_number: '555-1234'
  }
});

// Update records
executeAction('Individual', 'update', {
  id: 456,
  attributes: { custom_fields: { synced: true } }
});

// Convenience wrappers also available:
listRecords(modelName, options)
getRecord(modelName, id)
createRecord(modelName, attributes)
updateRecord(modelName, id, attributes)
deleteRecord(modelName, id)
findOrCreateRecord(modelName, findAttrs, createAttrs)

// Execute another DynamicFunction by name (synchronous by default)
const result = executeFunction('helper_function', { key: 'value' });

if (result.success) {
  console.log('Helper returned:', result.result);
} else {
  console.error('Helper failed:', result.error);
}

// Execute asynchronously (queued for background execution)
const asyncResult = executeFunction('long_running_task', { data: params.input }, true);
// Returns immediately: { success: true, message: '...', execution_id: ... }

// Chain multiple functions together
const validation = executeFunction('validate_data', { data: params.input });
if (!validation.success || !validation.result.valid) {
  return { success: false, error: 'Validation failed' };
}

const processed = executeFunction('process_data', {
  data: params.input,
  validationResult: validation.result
});

return processed.result;

// executeFunction(functionNameOrId, params, async)
// - functionNameOrId: Name or ID of the function
// - params: Parameters object (optional)
// - async: If true, queues for background execution (optional, default: false)

// Look up external ID for a local record
var result = getExternalId('Party', partyId, 'xero', 'xero_user_id');
if (result.found) {
  console.log('Xero user ID:', result.external_id);
}

// Find local record by external ID
var projectMapping = findByExternalId('Project', 'xero', xeroProjectId);
if (projectMapping.found) {
  var localProject = projectMapping.record;
}

// Store a new mapping
storeExternalMapping('Project', localProjectId, 'xero', xeroProjectId, {
  column_name: 'xero_project_id',
  table_name: 'xero_projects',
  is_primary_key: true
});

Functions can be scheduled to run automatically using cron expressions. The scheduler checks every 30 seconds for functions due to execute.

// Create a scheduled function
POST /api/v1/dynamic_functions
{
  "dynamic_function": {
    "name": "daily_sync",
    "description": "Sync contacts with CRM every morning",
    "javascript_code": "/* sync logic */",
    "schedule": "0 9 * * *",
    "timeout_seconds": 120,
    "run_as_user_id": 123,
    "active": true
  }
}

Functions can be triggered automatically when records are created, updated, or destroyed. This enables event-driven automation without polling.

// Create a callback function for task creation
POST /api/v1/dynamic_functions
{
  "dynamic_function": {
    "name": "on_task_created",
    "description": "Notify team when tasks are created",
    "callback_model": "Task",
    "callback_event": "create",
    "run_as_user_id": 123,
    "javascript_code": `
      // Context includes: event, model_name, record_id, record
      console.log('Task created:', record.name);

      // Send notification to external system
      await fetch('https://slack.com/api/chat.postMessage', {
        method: 'POST',
        headers: {
          'Authorization': 'Bearer ' + oauth.accessToken,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          channel: '#tasks',
          text: 'New task created: ' + record.name
        })
      });

      return { notified: true };
    `
  }
}

Dynamic Functions support OAuth 2.0 for integrating with external services. OAuth is configuration-based, meaning any OAuth 2.0 provider can be used without code changes.

OAuth Configuration

{
  "oauth": {
    "provider": "xero",
    "client_id": "YOUR_CLIENT_ID",
    "client_secret": "YOUR_CLIENT_SECRET",
    "authorize_url": "https://login.xero.com/identity/connect/authorize",
    "token_url": "https://identity.xero.com/connect/token",
    "scopes": ["openid", "profile", "accounting.transactions.read"]
  }
}

OAuth Flow

AI agents can manage and execute Dynamic Functions via five dedicated MCP tools. This enables intelligent automation where AI can create, modify, and run custom code.

mdi-forum What is the Communications Hub?

The Communications Hub connects Harmoniq conversations to external messaging platforms — Microsoft Teams, Slack, Discord, Twilio SMS, and Twilio Voice. Once configured, messages flow bidirectionally: when someone sends a message in Teams or Slack, it appears in the linked Harmoniq conversation. When an AI agent or user replies in Harmoniq, the response is delivered back to the external platform.

This enables powerful workflows: a customer can text your Twilio number and get an AI-powered response, your team can interact with AI agents directly in their Teams or Slack channels, and all conversations are centralized in Harmoniq with full history, analytics, and agent capabilities.

How it works

Supported channels

mdi-identifier Finding Your Tenant ID

Throughout this guide, webhook URLs include your tenant ID. This is the numeric ID of your tenant in Harmoniq. You'll need it when configuring webhook URLs on external platforms.

Your tenant ID is visible in the Harmoniq admin area, or you can find it by calling the API:

curl -H "Authorization: Bearer YOUR_JWT" \
     -H "Content-Type: application/json" \
     https://www.dsiloed.com/api/v1/parties?role_type_id=tenant

Look for your tenant in the response — the id field is your tenant ID.

mdi-robot AI Agent Display Names

When AI agents reply from Harmoniq, the Hub can display the agent's name instead of the generic bot name on platforms that support it (currently Slack). For example, if you have an agent named "Dilbert", their replies in Slack will show "Dilbert" as the sender rather than "Portablemind Bot".

This happens automatically — no extra configuration needed. The agent's display name is passed through with the outbound message.

mdi-microsoft Microsoft Teams Setup

Connecting Microsoft Teams requires creating an Azure Bot and a Teams App Package. This is the most involved setup of the five channels, but each step is straightforward.

Step 1: Create an Azure App Registration

1. Go to Azure Portal → App registrations
2. Click New registration
3. Name: Choose something descriptive (e.g., "Harmoniq Bot")
4. Supported account types: Accounts in any organizational directory (Multitenant)
5. Redirect URI: Leave blank for now
6. Click Register
7. On the app's Overview page, copy these two values — you'll need them later:

   Application (client) ID	This is your bot_id
   Directory (tenant) ID	This is your Azure tenant_id

Step 2: Create a Client Secret

1. In your app registration, go to Certificates & secrets
2. Click New client secret
3. Add a description (e.g., "Harmoniq Hub") and choose an expiry period
4. Click Add
5. Copy the Value immediately — it will only be shown once. This is your bot_password.

Step 3: Create an Azure Bot Resource

1. Go to Azure Portal → Create a resource → Azure Bot
2. Bot handle: Choose a unique name
3. Pricing tier: Free (F0) is fine for getting started
4. Type of App: Multi Tenant
5. Creation type: Use existing app registration
6. App ID: Paste your Application (client) ID from Step 1
7. Click Review + create, then Create

Step 4: Set the Messaging Endpoint

1. Open your Azure Bot resource
2. Go to Configuration
3. Set Messaging endpoint to:

   https://hub.portablemind.ai/webhooks/msteams/YOUR_TENANT_ID/messages

   Replace YOUR_TENANT_ID with your Harmoniq tenant ID.
4. Click Apply

Step 5: Enable the Teams Channel

1. In your Azure Bot resource, go to Channels
2. Click Microsoft Teams
3. Accept the terms and click Apply

Step 6: Add Graph API Permission (for Channel Discovery)

This permission allows Harmoniq to list your Teams channels when linking conversations.

1. Go back to your App registration → API permissions
2. Click Add a permission → Microsoft Graph → Application permissions
3. Search for and add: Channel.ReadBasic.All
4. Click Grant admin consent (requires admin privileges)

Step 7: Find Your Team ID

The Team ID is needed for channel discovery. To find it:

1. In Microsoft Teams, click the … (three dots) next to your team name
2. Select Get link to team
3. The URL contains your Team ID as the groupId parameter:

   https://teams.microsoft.com/l/team/...?groupId=97d8107a-2d4f-4280-84d2-ed0a3dd0051d&tenantId=...
                                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                                                                                             This is your Team ID

If you have multiple teams, comma-separate their IDs.

Step 8: Sideload the Teams App

You need a Teams App Package (a .zip file) to install the bot in your Teams tenant.

1. Create a manifest.json file with your bot's Application (client) ID
2. Include two icon files (color icon 192x192, outline icon 32x32)
3. Zip all three files together
4. In Teams, go to Apps → Manage your apps → Upload an app → Upload a custom app
5. Select your .zip file and install it

For a complete manifest.json template, see the Teams manifest schema documentation.

Step 9: Store Credentials in Harmoniq

Save the following credentials in your Harmoniq tenant's MS Teams Channel configuration:

mdi-chat-processing Slack Setup

Connecting Slack involves creating a Slack App, adding the right permissions, and configuring event subscriptions so Slack notifies the Hub when messages arrive.

Step 1: Create a Slack App

1. Go to api.slack.com/apps
2. Click Create New App → From scratch
3. Give your app a name (e.g., "Harmoniq Bot") and select your workspace
4. Click Create App

Step 2: Add Bot Token Scopes

Go to OAuth & Permissions in the sidebar, scroll to Scopes, and add these Bot Token Scopes:

Step 3: Install the App to Your Workspace

1. Still on OAuth & Permissions, scroll up and click Install to Workspace
2. Review the permissions and click Allow
3. Copy the Bot User OAuth Token (starts with xoxb-) — this is your slack_bot_token

Step 4: Get the Signing Secret

1. Go to Basic Information in the sidebar
2. Under App Credentials, copy the Signing Secret — this is your slack_signing_secret

Step 5: Enable Event Subscriptions

1. Go to Event Subscriptions in the sidebar
2. Toggle it ON
3. Set the Request URL to:

   https://hub.portablemind.ai/webhooks/slack/YOUR_TENANT_ID/events

   Slack will send a verification challenge — the Hub responds automatically. You should see a green "Verified" checkmark.
4. Expand Subscribe to bot events and click Add Bot User Event for each:

   Event	Description
   message.channels	Messages in public channels the bot is in
   message.groups	Messages in private channels the bot is in
   message.im	Direct messages to the bot

5. Click Save Changes

Step 6: Store Credentials in Harmoniq

Save the following in your tenant's Slack Channel configuration:

Step 7: Invite the Bot to Channels

To invite the bot to a channel:

1. Open the Slack channel
2. Type /invite @YourBotName
3. The bot will now receive messages and can respond in that channel

Recommended workflow: Link the channel in Harmoniq first, then invite the bot in Slack. Unlike Teams, the bot receives all messages in a channel — no @mention required.

mdi-gamepad-variant Discord Setup

Discord integration connects text channels in your Discord server to Harmoniq conversations. The bot listens for messages via Discord's Gateway (WebSocket) connection.

Step 1: Create a Discord Application

1. Go to Discord Developer Portal
2. Click New Application
3. Name it (e.g., "Harmoniq Bot") and click Create

Step 2: Add a Bot

1. Go to the Bot section in the sidebar
2. Click Reset Token and copy the token immediately — this is your bot_token
3. Under Privileged Gateway Intents, enable Message Content Intent
4. Click Save Changes

Step 3: Invite the Bot to Your Server

1. Go to OAuth2 → URL Generator in the sidebar
2. Under Scopes, check bot
3. Under Bot Permissions, check:
   • Send Messages
   • Read Message History
   • View Channels
4. Copy the generated URL at the bottom, open it in your browser, and select the server to add the bot to

Step 4: Get the Server (Guild) ID

1. In Discord, go to User Settings → Advanced → enable Developer Mode
2. Right-click on your server name in the sidebar
3. Click Copy Server ID — this is your guild_id

Step 5: Store Credentials in Harmoniq

mdi-cellphone-message Twilio SMS Setup

Twilio SMS enables your Harmoniq conversations to send and receive text messages. When someone texts your Twilio number, the message appears in the linked Harmoniq conversation. If no conversation is linked, one is created automatically.

Step 1: Get Your Twilio Credentials

1. Log in to the Twilio Console
2. On the dashboard, find and copy:

   Account SID	Starts with AC — this is your twilio_account_sid
   Auth Token	Click to reveal — this is your twilio_auth_token

Step 2: Get a Phone Number

1. In Twilio Console, go to Phone Numbers → Manage → Buy a number
2. Choose a number with SMS capability
3. Note the number in E.164 format (e.g., +18005551234) — this is your twilio_phone_number

Step 3: Configure Twilio Webhooks

1. Go to Phone Numbers → Manage → Active Numbers → click your number
2. Under Messaging:

   Setting	Value
   A message comes in	Webhook, POST, https://hub.portablemind.ai/webhooks/twilio/YOUR_TENANT_ID/sms/inbound
   Status callback URL	https://hub.portablemind.ai/webhooks/twilio/YOUR_TENANT_ID/sms/status

3. Click Save

Step 4: Store Credentials in Harmoniq

Auto-Created Conversations

When an SMS arrives from a phone number that isn't linked to any Harmoniq conversation, the system automatically creates a new conversation and links it. The conversation is named twilio-sms-+18005551234 with the phone number in the description. Future messages from the same number route to the same conversation.

Outbound SMS Registration Requirements

mdi-phone Twilio Voice Setup

Twilio Voice provides an AI-powered voice agent that answers inbound calls with real-time speech recognition and text-to-speech. The agent can look up caller context from Harmoniq (who is calling, their history, open projects) and perform mid-call data lookups triggered by natural language.

Voice uses the same Twilio account and phone number as SMS. If you've already set up SMS, you just need to add the voice webhook and a few extra configuration values.

Step 1: Configure the Voice Webhook

1. In Twilio Console, go to Phone Numbers → Manage → Active Numbers → click your number
2. Under Voice & Fax:

   Setting	Value
   A call comes in	Webhook, HTTP POST, https://hub.portablemind.ai/webhooks/twilio/YOUR_TENANT_ID/voice/twiml

3. Click Save

Step 2: Get an OpenAI API Key

The voice agent uses a fast OpenAI model (GPT-4o-mini by default) for real-time responses during calls. This is separate from the LLM models used in Harmoniq conversations.

1. Go to OpenAI API Keys
2. Create a new key and copy it

Step 3: Store Credentials in Harmoniq

Save the following in your tenant's Twilio Voice Channel configuration:

Voice + SMS Shared Conversations

Voice and SMS share the same conversation for a given phone number. When a caller's phone number is mapped to an SMS conversation, voice calls from that number will load the same conversation context and post transcripts to the same thread.

Caller Context Enrichment

When context_provider is set to harmoniq, the voice agent automatically looks up the caller's phone number in Harmoniq to find who they are, what projects they're associated with, and any relevant history. This context is injected into the AI prompt so the agent can greet the caller by name and have informed conversations.

mdi-link-variant Linking Channels to Conversations

After setting up credentials, you link external channels to specific Harmoniq conversations. This determines which conversation receives messages from which external channel.

1. Open a conversation in Harmoniq
2. Click the Channel Settings icon
3. Go to the External Channels tab
4. Click Add Mapping
5. Select Communications Hub as the external system
6. Choose the resource type:

   Resource Type	How it works
   Discord Channels	Search and select a channel from your Discord server
   Slack Channels	Search and select a channel from your Slack workspace
   Teams Conversations	Search and select a channel from your Teams team
   SMS Conversations	Enter a phone number in E.164 format (e.g., +18005551234)

7. Save the mapping

Cross-Channel Bridging

A single Harmoniq conversation can be linked to multiple external channels across different platforms. When a message arrives on any linked channel, it is fanned out to all other linked channels on the same conversation. This means a Discord message will appear in Teams and Slack, and vice versa.

Webhook URL Reference

These are the webhook URLs used by each channel (replace YOUR_TENANT_ID with your actual tenant ID):

mdi-wrench Troubleshooting

DSiloed comes with several sample applications that demonstrate different capabilities of the platform. Each app is built as a static JavaScript application that interacts with the API.

Building your own application on top of DSiloed is straightforward. You can use any modern JavaScript framework that can make HTTP requests to the API.

# Create the main app directory
mkdir -p myapp

# Create subdirectories for CSS, JavaScript, and documentation
mkdir -p myapp/css
mkdir -p myapp/js
mkdir -p myapp/js/components
mkdir -p myapp/docs

# Create basic files
touch myapp/index.html
touch myapp/css/styles.css
touch myapp/js/app.js

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My App - DSiloed</title>

    <!-- Vue and Vuetify -->
    <link href="https://cdn.jsdelivr.net/npm/vuetify@3.5.11/dist/vuetify.min.css" rel="stylesheet">
    <link href="https://cdn.jsdelivr.net/npm/@mdi/font@7.4.47/css/materialdesignicons.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css?family=Roboto:100,300,400,500,700,900" rel="stylesheet">

    <!-- Custom styles -->
    <link rel="stylesheet" href="css/styles.css?v=1771863622">

    <!-- Auth helper -->
    <script src="js/auth.js?v=1771863622"></script>
    <script src="js/components/LoginDialog.js?v=1771863622"></script>

    <!-- App scripts -->
    <script src="https://cdn.jsdelivr.net/npm/vue@3.4.21/dist/vue.global.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/vuetify@3.5.11/dist/vuetify.min.js"></script>
    <script src="js/app.js?v=1771863622" defer></script>
</head>
<body>
    <div id="app" v-cloak>
        <v-app>
            <v-app-bar color="primary" app>
                <v-app-bar-title>My App</v-app-bar-title>
            </v-app-bar>

            <v-main>
                <v-container>
                    <h1>My Custom App</h1>
                    <p>Welcome to my custom DSiloed application!</p>
                </v-container>
            </v-main>
        </v-app>
    </div>
</body>
</html>

// Initialize Vue app
document.addEventListener('DOMContentLoaded', function() {
  const { createApp } = Vue;
  const { createVuetify } = Vuetify;
  
  // Initialize authentication
  const authManager = new AuthManager('myapp');
  
  // Create Vuetify instance
  const vuetify = createVuetify();
  
  const app = createApp({
    data() {
      return {
        authManager: authManager,
        isAuthenticated: false,
        user: null,
      }
    },
    
    methods: {
      async initialize() {
        // Initialize authentication
        const authResult = await this.authManager.initialize();
        this.isAuthenticated = authResult.authenticated;
        this.user = authResult.user;
        
        // Show login if not authenticated
        if (!this.isAuthenticated) {
          this.showLogin();
        }
      },
      
      showLogin() {
        const loginDialog = new LoginDialog('myapp');
        loginDialog.onLogin = (result) => {
          if (result.success) {
            this.isAuthenticated = true;
            this.user = result.user;
            console.log('Logged in as:', this.user.email);
          }
        };
        loginDialog.show();
      },
      
      logout() {
        this.authManager.logout();
        this.isAuthenticated = false;
        this.user = null;
      }
    },
    
    mounted() {
      this.initialize();
    }
  });
  
  app.use(vuetify);
  app.mount('#app');
});

# Create a new React app
npx create-react-app my-model-api-app

# Navigate to the app directory
cd my-model-api-app

# Install Material UI and other dependencies
npm install @mui/material @mui/icons-material @emotion/react @emotion/styled

// src/utils/auth.js
export class AuthManager {
  constructor(appName) {
    this.appName = appName;
    this.authToken = localStorage.getItem('auth_token');
    this.tenantId = localStorage.getItem('tenant_id');
    this.user = null;
  }

  isAuthenticated() {
    return !!this.authToken;
  }

  getToken() {
    return this.authToken;
  }

  getTenantId() {
    return this.tenantId;
  }

  async loadUserInfo() {
    if (!this.isAuthenticated()) {
      return null;
    }

    try {
      const response = await fetch('https://modelapi.russonrails.com/api/v1/users/current', {
        headers: {
          'Authorization': 'Bearer ' + this.authToken,
          'Tenant-Id': this.tenantId || 'root-tenant'
        }
      });

      const data = await response.json();
      
      if (data.success) {
        this.user = data.user;
        return this.user;
      } else {
        this.logout();
        return null;
      }
    } catch (error) {
      console.error('Error loading user info:', error);
      return null;
    }
  }

  async login(email, password, tenantId) {
    try {
      const response = await fetch('https://modelapi.russonrails.com/api/v1/users/login', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Tenant-Id': tenantId
        },
        body: JSON.stringify({
          email: email,
          password: password
        })
      });

      const data = await response.json();
      
      if (data.success) {
        this.authToken = data.token;
        this.tenantId = tenantId;
        
        localStorage.setItem('auth_token', this.authToken);
        localStorage.setItem('tenant_id', this.tenantId);
        
        await this.loadUserInfo();
        
        return { success: true, user: this.user };
      } else {
        return { success: false, message: data.message || 'Invalid email or password' };
      }
    } catch (error) {
      console.error('Login error:', error);
      return { success: false, message: 'An error occurred during login. Please try again.' };
    }
  }

  logout() {
    this.authToken = null;
    this.user = null;
    localStorage.removeItem('auth_token');
    localStorage.removeItem('tenant_id');
    window.location.href = window.location.pathname;
  }

  async initialize() {
    if (this.isAuthenticated()) {
      const user = await this.loadUserInfo();
      return { authenticated: true, user: user };
    }
    return { authenticated: false };
  }
}

// src/components/LoginDialog.jsx
import React, { useState } from 'react';
import {
  Dialog, DialogTitle, DialogContent, DialogActions,
  TextField, Button, CircularProgress, Alert
} from '@mui/material';

function LoginDialog({ open, onClose, onLogin, authManager }) {
  const [email, setEmail] = useState('');
  const [password, setPassword] = useState('');
  const [tenantId, setTenantId] = useState('');
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState('');

  const handleSubmit = async (e) => {
    e.preventDefault();
    setError('');
    setLoading(true);

    try {
      if (!tenantId) {
        setError('Tenant ID is required');
        setLoading(false);
        return;
      }

      const result = await authManager.login(email, password, tenantId);

      if (result.success) {
        onLogin(result);
        onClose();
      } else {
        setError(result.message || 'Login failed');
      }
    } catch (err) {
      setError('An unexpected error occurred. Please try again.');
    } finally {
      setLoading(false);
    }
  };

  return (
    

      Login to {authManager.appName}
      

        
          {error && {error}}

           setEmail(e.target.value)}
            required
          />

           setPassword(e.target.value)}
            required
          />

           setTenantId(e.target.value)}
            required
          />
        

        
          Cancel
          
            {loading ?  : 'Login'}
          
        
      
    
  );
}

export default LoginDialog;

// src/App.jsx
import React, { useState, useEffect, useRef } from 'react';
import { 
  Container, AppBar, Toolbar, Typography, Button, 
  ThemeProvider, createTheme, CssBaseline, Box
} from '@mui/material';
import { AuthManager } from './utils/auth';
import LoginDialog from './components/LoginDialog';

const theme = createTheme({
  palette: {
    primary: {
      main: '#3161FF',
    },
    secondary: {
      main: '#6C63FF',
    },
  },
});

function App() {
  const [isAuthenticated, setIsAuthenticated] = useState(false);
  const [user, setUser] = useState(null);
  const [loginOpen, setLoginOpen] = useState(false);
  const authManager = useRef(new AuthManager('myapp')).current;
  
  useEffect(() => {
    const initializeAuth = async () => {
      try {
        const authResult = await authManager.initialize();
        setIsAuthenticated(authResult.authenticated);
        setUser(authResult.user);
      } catch (error) {
        console.error('Auth initialization error:', error);
      }
    };
    
    initializeAuth();
  }, []);
  
  const handleLogin = (result) => {
    if (result.success) {
      setIsAuthenticated(true);
      setUser(result.user);
    }
  };
  
  const handleLogout = () => {
    authManager.logout();
    setIsAuthenticated(false);
    setUser(null);
  };
  
  return (
    
      
      

        
          
            
              My App
            
            {isAuthenticated ? (
              <>
                
                  {user?.email}
                
                Logout
              
            ) : (
               setLoginOpen(true)}>Login
            )}
          
        
        
        
          {isAuthenticated ? (
            
              
                My Custom App
              
              
                Welcome to my custom DSiloed application!
              
            
          ) : (
            
              
                Welcome to My App
              
              
                Please log in to access the application.
              
               setLoginOpen(true)}
              >
                Login
              
            
          )}
        
        
         setLoginOpen(false)}
          onLogin={handleLogin}
          authManager={authManager}
        />
      
    
  );
}

export default App;

// Example API hook (src/hooks/useApi.js)
import { useState, useCallback } from 'react';

export function useApi(authManager) {
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);

  const headers = useCallback(() => ({
    'Authorization': 'Bearer ' + authManager.getToken(),
    'Tenant-Id': authManager.getTenantId(),
    'Content-Type': 'application/json'
  }), [authManager]);

  const fetchData = useCallback(async (endpoint, options = {}) => {
    if (!authManager.isAuthenticated()) {
      setError('Authentication required');
      return null;
    }

    setLoading(true);
    setError(null);

    try {
      const response = await fetch(`https://modelapi.russonrails.com/api/v1/${endpoint}`, {
        ...options,
        headers: {
          ...headers(),
          ...(options.headers || {})
        }
      });

      const data = await response.json();

      if (!data.success) {
        throw new Error(data.error?.message || 'API request failed');
      }

      return data;
    } catch (err) {
      setError(err.message);
      return null;
    } finally {
      setLoading(false);
    }
  }, [authManager, headers]);

  return { loading, error, fetchData };
}

// Using the hook in a component:
function PartyList() {
  const [parties, setParties] = useState([]);
  const authManager = useRef(new AuthManager('myapp')).current;
  const { loading, error, fetchData } = useApi(authManager);

  const loadParties = useCallback(async () => {
    const data = await fetchData('parties');
    if (data) {
      setParties(data.parties);
    }
  }, [fetchData]);

  useEffect(() => {
    if (authManager.isAuthenticated()) {
      loadParties();
    }
  }, [authManager, loadParties]);

  if (loading) return ;
  if (error) return {error};

  return (
    
      {parties.map(party => (
        
          
        
      ))}
    
  );
}

The ChatAssistant component provides a reusable, framework-independent chat interface that you can easily add to any application. It works with Vue.js, React, vanilla JavaScript, or any other framework.

Basic Usage

// Include the ChatAssistant component
<script src="js/components/ChatAssistant.js?v=1771863622"></script>

// Initialize in your application
const chatAssistant = new ChatAssistant('MyApp', {
    apiClient: apiClient,  // Your API client instance
    title: 'AI Assistant',
    placeholder: 'Ask me anything...',
    contextMessage: 'Assistant has access to your application data'
});

// Show/hide the chat
chatAssistant.toggle();

Vue.js Integration Example

// In your Vue app
methods: {
    initChatAssistant() {
        this.chatAssistant = new ChatAssistant('MyApp', {
            apiClient: apiClient,
            title: 'MyApp Assistant',
            placeholder: 'Ask about your data...',
            contextMessage: 'Assistant can help with your application',
            onError: (error) => {
                this.showSnackbar('Chat error: ' + error.message, 'error');
            }
        });
    },
    
    toggleChat() {
        if (this.chatAssistant) {
            this.chatAssistant.toggle();
        }
    }
},

mounted() {
    this.initChatAssistant();
}

React Integration Example

import { useEffect, useRef } from 'react';

function MyApp() {
    const chatAssistantRef = useRef(null);
    
    useEffect(() => {
        // Initialize ChatAssistant
        chatAssistantRef.current = new ChatAssistant('MyApp', {
            apiClient: apiClient,
            title: 'MyApp Assistant',
            onError: (error) => {
                showErrorToast(error.message);
            }
        });
        
        // Cleanup on unmount
        return () => {
            if (chatAssistantRef.current) {
                chatAssistantRef.current.destroy();
            }
        };
    }, []);
    
    const toggleChat = () => {
        if (chatAssistantRef.current) {
            chatAssistantRef.current.toggle();
        }
    };
    
    return (
        <div>
            <button onClick={toggleChat}>
                Toggle Chat Assistant
            </button>
            {/* Your app content */}
        </div>
    );
}

Configuration Options

const chatAssistant = new ChatAssistant('AppName', {
    // Required
    apiClient: apiClientInstance,
    
    // UI Configuration
    title: 'AI Assistant',
    placeholder: 'Ask me anything...',
    contextMessage: 'Assistant has access to your data',
    position: 'right', // 'left' or 'right'
    width: '400px',
    height: '600px',
    zIndex: 1000,
    
    // Event Callbacks
    onToggle: (isVisible) => {
        console.log('Chat toggled:', isVisible);
    },
    onMessage: (message) => {
        console.log('New message:', message);
    },
    onError: (error) => {
        console.error('Chat error:', error);
    }
});

You can use Large Language Models (LLMs) like Claude to help you build applications on top of DSiloed. Here's a prompt template to help you get started:

Simply modify the prompt template above to specify your application's requirements, then paste it to an LLM like Claude or GPT to get help building your application.

Now that you've explored the DSiloed platform, here are some next steps to continue your journey:

A Code Workspace record describes:

Before creating workspaces, your remote server needs:

The Dev Team Configuration stores shared settings for all workspaces in your tenant. This is a Configuration record with the internal identifier dev_team.

Required fields:

Optional fields:

API Equivalent

POST /api/v1/configurations

{
  "configuration": {
    "internal_identifier": "dev_team",
    "description": "Dev Team Configuration",
    "is_template": false,
    "config_values": {
      "ssh_host": "35.226.181.23",
      "ssh_port": 22,
      "ssh_username": "rholmes",
      "ssh_private_key": "-----BEGIN OPENSSH PRIVATE KEY-----\n...",
      "workspace_base_path": "/home/rholmes/code-workspaces",
      "git_provider": "gitlab",
      "repo_clone_url": "git@gitlab.com:model-api/model_api.git",
      "allowed_commands": "bundle,rspec,rubocop,rake,yarn,npm,node,npx,git"
    }
  }
}

Once the Dev Team Config is saved, you can create workspaces from the Workspaces tab.

Workspace fields:

API Equivalent

POST /api/v1/code_workspaces

{
  "code_workspace": {
    "name": "Model API Dev",
    "hostname": "35.226.181.23",
    "port": 22,
    "ssh_username": "rholmes",
    "working_directory": "/home/rholmes/code-workspaces/harmoniq/model-api-dev/repo",
    "default_branch": "master",
    "workspace_config": {
      "test_command": "bundle exec rspec",
      "lint_command": "bundle exec rubocop",
      "allowed_commands": ["bundle", "rspec", "rubocop", "rake", "git", "ruby"]
    }
  }
}

Workspaces need SSH credentials to connect to the remote server. If your Dev Team Config includes an ssh_private_key, credentials are created automatically when a workspace is created.

To manually store or update credentials:

API Equivalent

POST /api/v1/code_workspaces/:id/store_credentials

{
  "ssh_username": "rholmes",
  "ssh_private_key": "-----BEGIN OPENSSH PRIVATE KEY-----\n..."
}

Verify that Harmoniq can connect to your remote server through the workspace.

API Equivalent

POST /api/v1/code_workspaces/:id/test_connection

Success response:

{
  "success": true,
  "code_workspace": {
    "id": 1,
    "name": "Model API Dev",
    "connection_status": "connected",
    "current_directory": "/home/rholmes/code-workspaces/harmoniq/model-api-dev/repo",
    "user_identity": "rholmes"
  }
}

Provisioning creates directories on the remote server and clones the repository. This happens automatically when an agent uses the WorkspaceManageTool or WorkspaceProvisionTool, but you can also trigger it manually.

API Equivalent

POST /api/v1/code_workspaces/:id/provision

What provisioning does:

All configuration lives in the workspace_config JSON field.

Commands & Timeouts

Docker Settings

File Filtering

When docker_container_name is set, the workspace operates in hybrid Docker mode. Code execution runs inside the Docker container, while file operations run directly on the host via SSH.

When a workspace is linked to an LLM Agent, the agent gains access to remote development tools:

mdi-link-variant What is SiloLink?

SiloLink is a local daemon that bridges Claude Code sessions to Harmoniq conversations. It runs on your machine and exposes an MCP (Model Context Protocol) server that Claude Code connects to, while maintaining a real-time WebSocket connection to the Harmoniq platform.

This enables powerful remote workflows: launch Claude Code sessions from the Harmoniq UI, monitor them from the Agent Dashboard, send commands from Slack or Discord, and receive progress notifications — all without being at the terminal.

How it works

1. Install SiloLink

git clone git@gitlab.com:model-api/silo_link.git
cd silo_link
pnpm install
pnpm build

# Make the CLI globally available
pnpm link --global

2. Configure

Run the interactive setup wizard:

silolink config

This creates ~/.silolink/config.json with the following fields:

3. Start SiloLink

# Foreground (see logs in terminal)
silolink start

# Background (daemon mode)
silolink start --daemon

# Check status
silolink status

# Launch a Claude session manually
silolink launch
silolink launch -p "Work on the auth refactor"

# Stop the daemon (kills all Claude sessions)
silolink stop

4. Health Check

curl http://localhost:3579/health
# { "status": "ok", "sessions": 2, "cable": "connected" }

Add SiloLink as an MCP server in your Claude Code settings (.claude.json or project .mcp.json):

{
  "mcpServers": {
    "silolink": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://localhost:3579/mcp"
      ]
    }
  }
}

Pre-Approving Permissions

To avoid per-call permission prompts, add to .claude/settings.json:

{
  "permissions": {
    "allow": [
      "mcp__silolink__remote_register",
      "mcp__silolink__remote_notify",
      "mcp__silolink__remote_ask",
      "mcp__silolink__remote_poll",
      "mcp__silolink__remote_check_messages",
      "mcp__silolink__remote_wait_for_command",
      "mcp__silolink__remote_sessions",
      "mcp__silolink__remote_unregister"
    ]
  }
}

Or use the wildcard: "mcp__silolink__*"

Skip All Permission Prompts

For a fully autonomous experience, you can launch Claude Code with the --dangerously-skip-permissions flag:

claude --dangerously-skip-permissions

This bypasses all tool permission prompts, not just SiloLink — Claude Code will execute file edits, shell commands, and MCP tool calls without asking.

Tool Examples

Registering a session

// Claude Code calls:
remote_register({ session_name: "model_api" })

// Returns:
{ session_id: "abc-123", conversation_id: 42, conversation_url: "https://www.dsiloed.com/conversations/42" }

Sending a notification

remote_notify({ message: "Tests passed — 142 examples, 0 failures" })

Asking for human input

// Blocks until someone replies
remote_ask({ question: "Should I proceed with the migration?", timeout: 300 })

// Returns:
{ response: "Yes, go ahead", sender_name: "rholmes" }

Waiting for commands (listening loop)

// Blocks until a message arrives or timeout
remote_wait_for_command({ timeout: 1800 })

// Returns:
{ message: "Run the test suite", sender_name: "rholmes" }

SiloLink can spawn and manage Claude Code sessions automatically using tmux. Each conversation gets its own Claude process.

Launch from Harmoniq UI

Auto-Launch on Inbound Message

When a message arrives on a SiloLink conversation with no active session, SiloLink automatically posts "Restarting session..." and spawns a new Claude process. The original message is buffered and delivered once Claude registers.

Multi-Session Support

Each conversation gets its own tmux session. Multiple sessions run simultaneously and independently.

# List active tmux sessions
tmux list-sessions | grep silolink

# Attach to watch Claude work
tmux attach -t silolink-claude-1774363497579

# Detach: Ctrl+B, D

Managing Sessions

SiloLink subscribes to a tenant-scoped ActionCable control channel on startup. The Harmoniq UI sends commands via REST API:

Launch Example

// POST /api/v1/silolink/launch
const response = await fetch('/api/v1/silolink/launch', {
  method: 'POST',
  headers: headers,
  body: JSON.stringify({
    name: 'my-feature-work',
    prompt: 'Work on the auth refactor'
  })
});

// Response:
// { success: true, conversation_id: 458, message: "Launch command sent to SiloLink" }

Requires launch, stop, or status capabilities on the Silolink resource (auto-assigned to Tenant Admin).

CLAUDE.md Integration

Add this to your project's CLAUDE.md to instruct Claude Code to use SiloLink automatically:

## Remote Communication (SiloLink)

When the SiloLink MCP server is connected:

1. Register with `remote_register({ session_name: "<name>" })`.
   If a conversation_id is provided, pass it too.
2. ALL communication MUST go through SiloLink.
3. Send progress updates with `remote_notify()`.
4. When idle, use the poll loop:
   - Call `remote_poll()` — returns instantly
   - If `{ pending: true }`: sleep 3s, then poll again
   - If message received: process it, notify result, resume
5. Use `remote_ask()` for quick questions needing reply.

Poll Loop Pattern (Recommended)

// Register (use conversation_id if provided)
remote_register({ session_name: "portablemind", conversation_id: 123 })

// Poll loop
while (idle) {
  result = remote_poll()
  if (result.pending) { sleep(3s); continue }
  handle(result.message)
  remote_notify({ message: "Done: ..." })
}

Channel Linking

SiloLink conversations in Harmoniq can be linked to external channels (Discord, Slack, Teams) using the Communications Hub.

Active SiloLink sessions appear in the Mission Control Agent Dashboard (/agent-dashboard) with real-time status tracking.