Capabilities

import { detectCapabilities } from '@localmode/core';

const capabilities = await detectCapabilities();

import {
  isWebGPUSupported,
  isWebNNSupported,
  isWASMSupported,
  isWASMSIMDSupported,
  isWASMThreadsSupported,
  isIndexedDBSupported,
  isWebWorkersSupported,
  isSharedArrayBufferSupported,
  isCrossOriginIsolated,
  isOPFSSupported,
  isBroadcastChannelSupported,
  isWebLocksSupported,
  isServiceWorkerSupported,
  isWebCryptoSupported,
} from '@localmode/core';

import { features } from '@localmode/core';

if (features.wasm && features.simd) {
  console.log('Fast WASM execution available');
}

import { runtime } from '@localmode/core';

if (runtime.isBrowser) { /* browser environment */ }
if (runtime.isNode) { /* Node.js environment */ }
if (runtime.isWebWorker) { /* Web Worker context */ }
if (runtime.isElectron) { /* Electron app */ }

import {
  detectBrowser,
  detectOS,
  detectDeviceType,
  detectGPU,
  getDeviceInfo,
  getMemoryInfo,
  getHardwareConcurrency,
  getStorageEstimate,
} from '@localmode/core';

const browser = detectBrowser();
console.log(`${browser.name} ${browser.version} (${browser.engine})`);

const gpu = detectGPU();
if (gpu) {
  console.log(`GPU: ${gpu.vendor} — ${gpu.renderer}`);
}

const cores = getHardwareConcurrency();
console.log(`CPU cores: ${cores}`);

const storage = await getStorageEstimate();
console.log(`Storage: ${storage?.usage}/${storage?.quota} bytes used`);

import { createCapabilityReport, formatCapabilityReport } from '@localmode/core';

const report = await createCapabilityReport();
const formatted = formatCapabilityReport(report);
console.log(formatted);

import { checkModelSupport } from '@localmode/core';

const support = await checkModelSupport('Llama-3.2-1B-Instruct-q4f16_1-MLC');

if (support.supported) {
  console.log('Model can run on this device');
} else {
  console.log('Issues:', support.issues);
  // ['Insufficient GPU memory', 'WebGPU not available']
}

import { getRecommendedFallbacks } from '@localmode/core';

const fallbacks = await getRecommendedFallbacks();

console.log(fallbacks);
// {
//   embedding: 'Xenova/bge-small-en-v1.5',      // Smaller model for limited devices
//   llm: 'SmolLM2-1.7B-Instruct-q4f16_1-MLC', // Compact LLM
//   storage: 'memory',                         // If IndexedDB unavailable
//   compute: 'wasm',                           // If WebGPU unavailable
// }

import { detectCapabilities } from '@localmode/core';
import { transformers } from '@localmode/transformers';
import { webllm } from '@localmode/webllm';

const capabilities = await detectCapabilities();

// Choose embedding model
const embeddingModel = capabilities.webgpu
  ? transformers.embedding('Xenova/all-MiniLM-L12-v2') // Larger, better
  : transformers.embedding('Xenova/bge-small-en-v1.5'); // Smaller, faster

// Choose LLM
let llm;
if (capabilities.webgpu && capabilities.memory?.available > 2048) {
  llm = webllm.languageModel('Llama-3.2-3B-Instruct-q4f16_1-MLC');
} else if (capabilities.webgpu) {
  llm = webllm.languageModel('Llama-3.2-1B-Instruct-q4f16_1-MLC');
} else {
  console.warn('WebGPU not available, LLM features disabled');
  llm = null;
}

import { detectCapabilities, isWebGPUSupported } from '@localmode/core';

async function initializeAI() {
  const capabilities = await detectCapabilities();
  const features = {
    embeddings: true,
    vectorSearch: true,
    llm: false,
    persistence: true,
  };

  // Check WebGPU for LLM
  if (!isWebGPUSupported()) {
    console.warn('WebGPU not available. LLM features disabled.');
    features.llm = false;
  } else if (capabilities.memory?.available < 1024) {
    console.warn('Low GPU memory. LLM may be slow.');
  } else {
    features.llm = true;
  }

  // Check IndexedDB for persistence
  if (!capabilities.indexedDB) {
    console.warn('IndexedDB not available. Data will not persist.');
    features.persistence = false;
  }

  return features;
}

// Usage
const features = await initializeAI();

if (features.llm) {
  // Show LLM features in UI
} else {
  // Hide or disable LLM features
}

import { detectCapabilities } from '@localmode/core';

const { gpu, memory } = await detectCapabilities();

if (gpu) {
  console.log('GPU Vendor:', gpu.vendor);
  console.log('GPU Renderer:', gpu.renderer);
}

if (memory) {
  console.log('Total Memory:', memory.total, 'MB');
  console.log('Available Memory:', memory.available, 'MB');
}

import { computeOptimalBatchSize } from '@localmode/core';

const { batchSize, reasoning, deviceProfile } = computeOptimalBatchSize({
  taskType: 'embedding',
  modelDimensions: 384,
});

console.log(batchSize);     // e.g., 32 on a 4-core/8GB device
console.log(reasoning);     // Human-readable explanation
console.log(deviceProfile); // { cores, memoryGB, hasGPU, source }

Math.max(min, Math.min(max, Math.floor(base * (cores / 4) * (memGB / 8) * gpuMult)))

const result = computeOptimalBatchSize({
  taskType: 'embedding',
  modelDimensions: 384,
  deviceCapabilities: { cores: 16, memoryGB: 32, hasGPU: true },
});
// batchSize: 256 (clamped to max)

import { streamEmbedMany } from '@localmode/core';

for await (const { embedding, index } of streamEmbedMany({
  model,
  values: largeArray,
  adaptiveBatching: true, // Computes batch size from device capabilities
})) {
  await db.add({ id: `doc-${index}`, vector: embedding });
}

import { ingest } from '@localmode/core';

await ingest(db, documents, {
  adaptiveBatching: true,
  chunking: { strategy: 'recursive', size: 500 },
});

import { useAdaptiveBatchSize } from '@localmode/react';

function BatchConfig() {
  const { batchSize, reasoning, deviceProfile } = useAdaptiveBatchSize({
    taskType: 'embedding',
    modelDimensions: 384,
  });

  return <p>Optimal batch size: {batchSize} ({deviceProfile.cores} cores)</p>;
}

import { detectCapabilities, recommendModels } from '@localmode/core';

const caps = await detectCapabilities();
const recs = recommendModels(caps, { task: 'embedding' });

for (const rec of recs) {
  console.log(`${rec.entry.name} — score: ${rec.score}`);
  console.log(`  Provider: ${rec.entry.provider}`);
  console.log(`  Size: ${rec.entry.sizeMB} MB`);
  console.log(`  Reasons: ${rec.reasons.join(', ')}`);
}

const recs = recommendModels(caps, {
  task: 'generation',
  providers: ['webllm'],
  maxSizeMB: 1000,
  limit: 3,
});

import { registerModel, recommendModels } from '@localmode/core';

registerModel({
  modelId: 'custom/my-embedder',
  provider: 'custom',
  task: 'embedding',
  name: 'My Custom Embedder',
  sizeMB: 50,
  dimensions: 384,
  recommendedDevice: 'wasm',
  speedTier: 'fast',
  qualityTier: 'medium',
});

// Custom model now appears in recommendations
const recs = recommendModels(caps, { task: 'embedding' });

import { getModelRegistry, DEFAULT_MODEL_REGISTRY } from '@localmode/core';

// Default curated catalog (read-only)
console.log(`${DEFAULT_MODEL_REGISTRY.length} curated models`);

// Full registry (defaults + custom)
const all = getModelRegistry();
const embeddingModels = all.filter(e => e.task === 'embedding');

import { useModelRecommendations } from '@localmode/react';

function ModelPicker() {
  const { recommendations, isLoading, error, refresh } = useModelRecommendations({
    task: 'embedding',
    limit: 3,
  });

  if (isLoading) return <p>Detecting device...</p>;
  if (error) return <p>Error: {error.message}</p>;

  return (
    <ul>
      {recommendations.map((rec) => (
        <li key={rec.entry.modelId}>
          {rec.entry.name} — score: {rec.score}
        </li>
      ))}
    </ul>
  );
}