Self-Hosted AI Assistant Platform Deployment on Windows 11 with LLM Integration Guide

Technical Overview

The self-hosted AI assistant platform offers three core advantages:

1. Data Sovereignty: Local storage of all interaction data ensures compliance with financial/healthcare regulations
2. Model Flexibility: Dynamic switching between LLM providers (GPT, Claude, GLM etc.) prevents vendor lock-in
3. Skill Ecosystem: Standardized APIs integrate document processing, web search, and other vertical capabilities

Typical use cases include:

• Enterprise knowledge base Q&A systems
• Automated customer service bots
• Personal productivity assistants (calendar management, document summarization)

System Requirements

Hardware Specifications

Component	Minimum	Recommended
OS	Windows 10/11	Windows 11 22H2
Memory	8GB	16GB DDR5
Storage	50GB NVMe SSD	1TB NVMe SSD
Network	100Mbps	Gigabit Ethernet

Software Setup

1. Node.js Installation:

   # Recommended package manager installation
   winget install --id OpenJS.NodeJS.LTS
   # Verify installation
   node -v
   npm -v

2. System Configuration:

   # Temporary Windows Defender disable
   Set-MpPreference -DisableRealtimeMonitoring $true
   # Script execution policy
   Set-ExecutionPolicy RemoteSigned -Scope CurrentUser -Force

Deployment Methods

Automated Installation

# Use official installation script
$installerUrl = "https://official-repo.example.com/install.ps1"
Invoke-WebRequest -Uri $installerUrl -OutFile "$env:TEMP\install.ps1"
& "$env:TEMP\install.ps1" -AcceptEula -SkipVersionCheck

Key installation stages:

1. Dependency validation (Node.js version, disk space)
2. Service account creation (LOCAL SYSTEM privileges)
3. Firewall configuration (8080/443 ports)
4. Auto-start service registration

Manual Deployment (Advanced)

1. Source Compilation:

   git clone https://github.com/example/platform-core.git
   cd platform-core
   npm install --production
   npm run build

2. Configuration File:

   {
     "service": {
       "port": 8080,
       "workerThreads": 4
     },
     "storage": {
       "type": "sqlite",
       "path": "./data/platform.db"
     }
   }

3. Service Registration:

   $action = New-ScheduledTaskAction -Execute "node" -Argument "dist/server.js"
   $trigger = New-ScheduledTaskTrigger -AtStartup
   Register-ScheduledTask -TaskName "AIAssistantService" -Action $action -Trigger $trigger -RunLevel Highest

LLM Integration

Authentication Setup

Example workflow for a major LLM provider:

1. Create developer account and complete verification
2. Obtain API credentials:
   • Client ID
   • Client Secret
   • API Gateway endpoint
3. Generate access token:

   $body = @{
     grant_type = "client_credentials"
     client_id  = "YOUR_CLIENT_ID"
     client_secret = "YOUR_CLIENT_SECRET"
   }
   $response = Invoke-RestMethod -Uri "https://auth.example.com/oauth2/token" -Method Post -Body $body
   $accessToken = $response.access_token

Model Routing Configuration

models:
  - name: "glm-4.7-flash"
    type: "completion"
    endpoint: "https://api.example.com/v1/completions"
    auth:
      type: "bearer"
      token: "${{ACCESS_TOKEN}}"
    params:
      max_tokens: 2048
      temperature: 0.7
    rate_limit:
      requests_per_minute: 120

Performance Optimization

1. Connection Pooling:

   const { Pool } = require('generic-pool');
   const modelPool = new Pool({
     create: () => createModelClient(),
     destroy: (client) => client.disconnect(),
     max: 10,
     min: 2
   });

2. Batch Processing:

   def batch_predict(requests):
       batch_size = 32
       results = []
       for i in range(0, len(requests), batch_size):
           batch = requests[i:i+batch_size]
           response = model_client.generate(batch)
           results.extend(response.choices)
       return results

Advanced Features

Skill Development

// skill-demo.ts
import { SkillContext, SkillResult } from '@platform/types';
export default class DemoSkill {
    async execute(ctx: SkillContext): Promise<SkillResult> {
        return {
            type: "text",
            content: `Current time: ${new Date().toLocaleString()}`
        };
    }
}

Monitoring Integration

# prometheus.yml
scrape_configs:
  - job_name: 'ai-assistant'
    static_configs:
      - targets: ['localhost:9090']
    metrics_path: '/metrics'
    params:
      format: ['prometheus']

Operational Management

Log Analysis

Key log locations:

• /var/log/ai-assistant/ (Linux)
• C:\ProgramData\AIAssistant\logs\ (Windows)

Recommended ELK stack pipeline:

Filebeat → Logstash → Elasticsearch → Kibana

Backup Strategy

1. Database Backup:

   sqlite3 ./data/platform.db ".backup '/backup/platform_$(date +%Y%m%d).db'"

2. Configuration Versioning:

   git init
   git add config/*.yml
   git commit -m "Initial configuration backup"

Troubleshooting

Installation Issues

1. Dependency Conflicts:

   # Check Node.js module version
   node -p "process.versions.modules"
   # Clear npm cache
   npm cache clean --force

2. Port Conflicts:

   # Identify占用进程
   netstat -ano | findstr :8080
   # Terminate process
   taskkill /PID 1234 /F

Model Errors

1. Authentication Failures:

   • Verify system time synchronization
   • Check token expiration (typically 2 hours)
   • Validate network proxy settings

2. Rate Limiting:

   import time
   import random
   def backoff_retry(max_retries=3):
       for i in range(max_retries):
           try:
               return yield from model_call()
           except RateLimitError:
               wait_time = min(2**i + random.uniform(0,1), 30)
               time.sleep(wait_time)

This implementation provides end-to-end coverage from environment setup to advanced operations. For production deployment, we recommend containerization with Docker and CI/CD pipeline integration. The modular architecture supports seamless integration with existing enterprise systems while maintaining compliance with data residency requirements.