nano-brain 2026.2.0 → 2026.3.1

package/docker-compose.qdrant.yml

@@ -0,0 +1,15 @@
+services:
+  qdrant:
+    image: qdrant/qdrant:latest
+    container_name: nano-brain-qdrant
+    restart: unless-stopped
+    ports:
+      - "6333:6333"
+      - "6334:6334"
+    volumes:
+      - nano-brain-qdrant-data:/qdrant/storage
+    environment:
+      - QDRANT__SERVICE__GRPC_PORT=6334
+volumes:
+  nano-brain-qdrant-data:
+    driver: local

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nano-brain",
-  "version": "2026.2.0",
+  "version": "2026.3.1",
   "type": "module",
   "bin": {
     "nano-brain": "./bin/cli.js"
@@ -17,6 +17,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "@qdrant/js-client-rest": "^1.17.0",
     "better-sqlite3": "^12.6.2",
     "chokidar": "^5.0.0",
     "fast-glob": "^3.3.3",

package/src/embeddings.ts

@@ -1,9 +1,10 @@
 import { getLlama } from 'node-llama-cpp';
-import { promises as fs, accessSync, readFileSync } from 'fs';
+import { promises as fs } from 'fs';
 import { join, dirname } from 'path';
 import { homedir, cpus } from 'os';
 import type { EmbeddingResult, EmbeddingConfig } from './types.js';
 import { log } from './logger.js';
+import { resolveHostUrl } from './host.js';
 
 export interface EmbeddingProvider {
   embed(text: string): Promise<EmbeddingResult>;
@@ -113,20 +114,7 @@ function formatDocumentPrompt(title: string, content: string): string {
 
 
 export function detectOllamaUrl(): string {
-  const isDocker = (() => {
-    try {
-      accessSync('/.dockerenv');
-      return true;
-    } catch {
-      try {
-        const cgroup = readFileSync('/proc/1/cgroup', 'utf-8');
-        return cgroup.includes('docker') || cgroup.includes('containerd');
-      } catch {
-        return false;
-      }
-    }
-  })();
-  return isDocker ? 'http://host.docker.internal:11434' : 'http://localhost:11434';
+  return resolveHostUrl('http://localhost:11434');
 }
 
 export async function checkOllamaHealth(url: string): Promise<{ reachable: boolean; models?: string[]; error?: string }> {

package/src/host.ts

@@ -0,0 +1,31 @@
+import { accessSync, readFileSync } from 'fs';
+
+let cachedIsInsideContainer: boolean | null = null;
+
+export function isInsideContainer(): boolean {
+  if (cachedIsInsideContainer !== null) {
+    return cachedIsInsideContainer;
+  }
+
+  try {
+    accessSync('/.dockerenv');
+    cachedIsInsideContainer = true;
+    return true;
+  } catch {
+    try {
+      const cgroup = readFileSync('/proc/1/cgroup', 'utf-8');
+      cachedIsInsideContainer = cgroup.includes('docker') || cgroup.includes('containerd');
+      return cachedIsInsideContainer;
+    } catch {
+      cachedIsInsideContainer = false;
+      return false;
+    }
+  }
+}
+
+export function resolveHostUrl(url: string): string {
+  if (!isInsideContainer()) {
+    return url;
+  }
+  return url.replace(/\b(localhost|127\.0\.0\.1)\b/g, 'host.docker.internal');
+}

package/src/index.ts

@@ -7,11 +7,16 @@ import { hybridSearch, parseSearchConfig } from './search.js';
 import { indexCodebase, embedPendingCodebase } from './codebase.js';
 import { findCycles } from './graph.js';
 import { handleBench } from './bench.js';
+import { resolveHostUrl } from './host.js';
+import { QdrantVecStore } from './providers/qdrant.js';
+import { createVectorStore } from './vector-store.js';
 import type { SearchResult } from './types.js';
+import type { VectorPoint } from './vector-store.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import * as crypto from 'crypto';
+import { execSync } from 'child_process';
 import { log, initLogger } from './logger.js';
 
 function resolveOpenCodeStorageDir(): string {
@@ -150,6 +155,17 @@ nano-brain - Memory system with hybrid search
     --json          Output as JSON
     --save          Save results as baseline
     --compare       Compare with last saved baseline
+  qdrant            Manage Qdrant vector store
+    up              Start Qdrant via Docker, configure as vector provider
+    down            Stop Qdrant, switch back to sqlite-vec
+    status          Show Qdrant container and collection health
+    migrate         Migrate vectors from SQLite to Qdrant
+      --workspace=<path>  Migrate specific workspace only
+      --batch-size=<n>    Vectors per batch (default: 500)
+      --dry-run           Show counts without migrating
+      --activate          Switch to Qdrant provider after migration
+    activate        Switch config to use Qdrant as vector provider
+    cleanup         Drop SQLite vector tables (requires Qdrant active with vectors)
 Logging Config (~/.nano-brain/config.yml):
   logging:
     enabled: true               # enable file logging (or use NANO_BRAIN_LOG=1 env)
@@ -744,6 +760,10 @@ async function handleSearch(
     results = store.searchFTS(query, { limit, collection, projectHash, tags, since, until });
   } else if (mode === 'vec') {
     const searchConfig = loadCollectionConfig(globalOpts.configPath);
+    if (searchConfig?.vector?.provider === 'qdrant' && searchConfig.vector.url) {
+      const vs = createVectorStore(searchConfig.vector);
+      store.setVectorStore(vs);
+    }
     const provider = await createEmbeddingProvider({ embeddingConfig: searchConfig?.embedding });
     if (!provider) {
       console.error('Vector search requires embedding model');
@@ -752,10 +772,14 @@ async function handleSearch(
     }
     
     const { embedding } = await provider.embed(query);
-    results = store.searchVec(query, embedding, { limit, collection, projectHash, tags, since, until });
+    results = await store.searchVecAsync(query, embedding, { limit, collection, projectHash, tags, since, until });
     provider.dispose();
   } else {
     const searchConfig = loadCollectionConfig(globalOpts.configPath);
+    if (searchConfig?.vector?.provider === 'qdrant' && searchConfig.vector.url) {
+      const vs = createVectorStore(searchConfig.vector);
+      store.setVectorStore(vs);
+    }
     const provider = await createEmbeddingProvider({ embeddingConfig: searchConfig?.embedding });
     results = await hybridSearch(
       store,
@@ -1301,6 +1325,527 @@ function printLastLines(filePath: string, n: number): void {
   }
 }
 
+interface VectorConfigSection {
+  provider: 'sqlite-vec' | 'qdrant';
+  url?: string;
+  apiKey?: string;
+  collection?: string;
+}
+
+async function handleQdrant(globalOpts: GlobalOptions, commandArgs: string[]): Promise<void> {
+  const subcommand = commandArgs[0];
+
+  if (!subcommand) {
+    console.error('Missing qdrant subcommand (up, down, status, migrate, activate, cleanup)');
+    process.exit(1);
+  }
+
+  log('cli', 'qdrant subcommand=' + subcommand);
+
+  const composeSource = path.join(path.dirname(new URL(import.meta.url).pathname), '..', 'docker-compose.qdrant.yml');
+  const composeTarget = path.join(NANO_BRAIN_HOME, 'docker-compose.qdrant.yml');
+
+  switch (subcommand) {
+    case 'up': {
+      if (!fs.existsSync(composeTarget)) {
+        if (!fs.existsSync(composeSource)) {
+          console.error('❌ docker-compose.qdrant.yml not found in package');
+          process.exit(1);
+        }
+        fs.mkdirSync(path.dirname(composeTarget), { recursive: true });
+        fs.copyFileSync(composeSource, composeTarget);
+      }
+
+      console.log('Starting Qdrant...');
+      try {
+        execSync(`docker compose -f "${composeTarget}" up -d`, { stdio: 'inherit' });
+      } catch {
+        console.error('❌ Failed to start Qdrant. Is Docker running?');
+        process.exit(1);
+      }
+
+      const healthUrl = resolveHostUrl('http://localhost:6333/healthz');
+      let healthy = false;
+      for (let i = 0; i < 5; i++) {
+        await new Promise(r => setTimeout(r, 2000));
+        try {
+          const res = await fetch(healthUrl);
+          if (res.ok) {
+            healthy = true;
+            break;
+          }
+        } catch {
+        }
+        console.log(`Waiting for Qdrant... (${i + 1}/5)`);
+      }
+
+      if (!healthy) {
+        console.error('❌ Qdrant failed to start. Check: docker logs nano-brain-qdrant');
+        process.exit(1);
+      }
+
+      let config = loadCollectionConfig(globalOpts.configPath);
+      if (!config) {
+        config = { collections: {} };
+      }
+      const vectorConfig: VectorConfigSection = {
+        provider: 'qdrant',
+        url: 'http://localhost:6333',
+        collection: 'nano-brain',
+      };
+      config.vector = vectorConfig;
+      saveCollectionConfig(globalOpts.configPath, config);
+
+      console.log('✅ Qdrant is running. Dashboard: http://localhost:6333/dashboard');
+      break;
+    }
+
+    case 'down': {
+      console.log('Stopping Qdrant...');
+      try {
+        execSync(`docker compose -f "${composeTarget}" down`, { stdio: 'inherit' });
+      } catch {
+        console.error('❌ Failed to stop Qdrant');
+        process.exit(1);
+      }
+
+      let config = loadCollectionConfig(globalOpts.configPath);
+      if (config) {
+        const vectorConfig: VectorConfigSection = { provider: 'sqlite-vec' };
+        config.vector = vectorConfig;
+        saveCollectionConfig(globalOpts.configPath, config);
+      }
+
+      console.log('✅ Qdrant stopped. Vector provider switched to sqlite-vec. Data persists in Docker volume.');
+      break;
+    }
+
+    case 'status': {
+      const config = loadCollectionConfig(globalOpts.configPath);
+      const vectorConfig = config?.vector;
+      const currentProvider = vectorConfig?.provider || 'sqlite-vec';
+
+      console.log('Qdrant Status');
+      console.log('═══════════════════════════════════════════════════');
+      if (currentProvider === 'qdrant') {
+        console.log(`Active provider: qdrant ✓`);
+      } else {
+        console.log(`Active provider: sqlite-vec (default)`);
+      }
+      console.log('');
+
+      let containerStatus = 'unknown';
+      try {
+        const output = execSync(`docker compose -f "${composeTarget}" ps --format json`, { encoding: 'utf-8' });
+        const lines = output.trim().split('\n').filter(l => l.trim());
+        for (const line of lines) {
+          try {
+            const info = JSON.parse(line);
+            if (info.Name === 'nano-brain-qdrant' || info.Service === 'qdrant') {
+              containerStatus = info.State || info.Status || 'running';
+              break;
+            }
+          } catch {
+          }
+        }
+      } catch {
+        containerStatus = 'not running';
+      }
+
+      console.log(`Container: ${containerStatus}`);
+
+      const qdrantUrl = vectorConfig?.url || 'http://localhost:6333';
+      const resolvedUrl = resolveHostUrl(qdrantUrl);
+
+      try {
+        const healthRes = await fetch(`${resolvedUrl}/healthz`);
+        if (!healthRes.ok) {
+          throw new Error(`HTTP ${healthRes.status}`);
+        }
+        console.log(`Health: ✅ reachable at ${resolvedUrl}`);
+
+        try {
+          const collectionRes = await fetch(`${resolvedUrl}/collections/nano-brain`);
+          if (collectionRes.ok) {
+            const collectionData = await collectionRes.json();
+            const result = collectionData.result || collectionData;
+            console.log(`Collection: nano-brain`);
+            console.log(`  Vectors: ${result.points_count ?? result.vectors_count ?? 'unknown'}`);
+            console.log(`  Dimensions: ${result.config?.params?.vectors?.size ?? 'unknown'}`);
+          } else {
+            console.log('Collection: nano-brain (not created yet)');
+          }
+        } catch {
+          console.log('Collection: nano-brain (not created yet)');
+        }
+      } catch {
+        console.log(`Health: ❌ Qdrant is not reachable at ${resolvedUrl}`);
+        if (resolvedUrl !== qdrantUrl) {
+          console.log(`   (config URL ${qdrantUrl} resolved to ${resolvedUrl} inside container)`);
+        }
+        console.log('   Run `npx nano-brain qdrant up` to start.');
+      }
+      break;
+    }
+
+    case 'migrate': {
+      let workspaceFilter: string | undefined;
+      let batchSize = 500;
+      let dryRun = false;
+      let activateAfter = false;
+
+      for (const arg of commandArgs.slice(1)) {
+        if (arg.startsWith('--workspace=')) {
+          workspaceFilter = arg.substring(12);
+        } else if (arg.startsWith('--batch-size=')) {
+          batchSize = parseInt(arg.substring(13), 10);
+        } else if (arg === '--dry-run') {
+          dryRun = true;
+        } else if (arg === '--activate') {
+          activateAfter = true;
+        }
+      }
+
+      const config = loadCollectionConfig(globalOpts.configPath);
+      const vectorConfig = config?.vector;
+      const qdrantUrl = vectorConfig?.url || 'http://localhost:6333';
+      const resolvedUrl = resolveHostUrl(qdrantUrl);
+
+      try {
+        const healthRes = await fetch(`${resolvedUrl}/healthz`);
+        if (!healthRes.ok) {
+          throw new Error(`HTTP ${healthRes.status}`);
+        }
+      } catch {
+        console.error(`❌ Qdrant is not reachable at ${resolvedUrl}.`);
+        console.error('   Run `npx nano-brain qdrant up` first.');
+        console.error('   If running inside a container, Qdrant must be accessible at host.docker.internal:6333.');
+        process.exit(1);
+      }
+
+      const dataDir = DEFAULT_DB_DIR;
+      if (!fs.existsSync(dataDir)) {
+        console.log('No databases found in ' + dataDir);
+        return;
+      }
+
+      let sqliteFiles = fs.readdirSync(dataDir).filter(f => f.endsWith('.sqlite'));
+      if (workspaceFilter) {
+        sqliteFiles = sqliteFiles.filter(f => f.includes(workspaceFilter));
+      }
+
+      if (sqliteFiles.length === 0) {
+        console.log('No matching databases found');
+        return;
+      }
+
+      console.log(`Found ${sqliteFiles.length} database(s) to migrate`);
+      if (dryRun) {
+        console.log('(dry-run mode - no vectors will be written)');
+      }
+
+      const startTime = Date.now();
+      let totalVectors = 0;
+      let dbCount = 0;
+
+      const Database = (await import('better-sqlite3')).default;
+      const sqliteVec = await import('sqlite-vec');
+
+      for (const sqliteFile of sqliteFiles) {
+        const dbPath = path.join(dataDir, sqliteFile);
+        const db = new Database(dbPath);
+
+        try {
+          sqliteVec.load(db);
+        } catch {
+          console.log(`[${sqliteFile}] sqlite-vec not available, skipping`);
+          db.close();
+          continue;
+        }
+
+        let vectorCount = 0;
+        try {
+          const countStmt = db.prepare(`
+            SELECT COUNT(*) as cnt FROM content_vectors cv
+            JOIN vectors_vec vv ON cv.hash || ':' || cv.seq = vv.hash_seq
+          `);
+          const countRow = countStmt.get() as { cnt: number };
+          vectorCount = countRow.cnt;
+        } catch {
+          console.log(`[${sqliteFile}] no vector tables, skipping`);
+          db.close();
+          continue;
+        }
+
+        if (vectorCount === 0) {
+          console.log(`[${sqliteFile}] 0 vectors, skipping`);
+          db.close();
+          continue;
+        }
+
+        if (dryRun) {
+          console.log(`[${sqliteFile}] ${vectorCount} vectors (dry-run)`);
+          totalVectors += vectorCount;
+          dbCount++;
+          db.close();
+          continue;
+        }
+
+        const qdrantStore = new QdrantVecStore({
+          url: resolvedUrl,
+          collection: vectorConfig?.collection || 'nano-brain',
+        });
+
+        const selectStmt = db.prepare(`
+          SELECT cv.hash, cv.seq, cv.pos, cv.model, vv.embedding,
+                 MIN(d.collection) as collection, MIN(d.project_hash) as project_hash
+          FROM content_vectors cv
+          JOIN vectors_vec vv ON cv.hash || ':' || cv.seq = vv.hash_seq
+          LEFT JOIN documents d ON cv.hash = d.hash AND d.active = 1
+          GROUP BY cv.hash, cv.seq
+        `);
+
+        const rows = selectStmt.all() as Array<{
+          hash: string;
+          seq: number;
+          pos: number;
+          model: string;
+          project_hash: string | null;
+          embedding: Buffer;
+          collection: string | null;
+        }>;
+
+        let migrated = 0;
+        const batch: VectorPoint[] = [];
+
+        for (const row of rows) {
+          const embeddingArray = Array.from(new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4));
+
+          const point: VectorPoint = {
+            id: `${row.hash}:${row.seq}`,
+            embedding: embeddingArray,
+            metadata: {
+              hash: row.hash,
+              seq: row.seq,
+              pos: row.pos,
+              model: row.model,
+              collection: row.collection || undefined,
+              projectHash: row.project_hash || undefined,
+            },
+          };
+
+          batch.push(point);
+
+          if (batch.length >= batchSize) {
+            await qdrantStore.batchUpsert(batch);
+            migrated += batch.length;
+            console.log(`[${sqliteFile}] ${migrated}/${vectorCount} vectors migrated...`);
+            batch.length = 0;
+          }
+        }
+
+        if (batch.length > 0) {
+          await qdrantStore.batchUpsert(batch);
+          migrated += batch.length;
+        }
+
+        console.log(`[${sqliteFile}] ${migrated}/${vectorCount} vectors migrated`);
+        totalVectors += migrated;
+        dbCount++;
+
+        await qdrantStore.close();
+        db.close();
+      }
+
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+      if (dryRun) {
+        console.log(`\n📊 Dry-run complete: ${totalVectors} vectors in ${dbCount} database(s)`);
+      } else {
+        console.log(`\n✅ Migrated ${totalVectors} vectors from ${dbCount} database(s) in ${elapsed}s`);
+
+        const currentProvider = config?.vector?.provider || 'sqlite-vec';
+        if (currentProvider !== 'qdrant') {
+          if (activateAfter) {
+            let updatedConfig = loadCollectionConfig(globalOpts.configPath);
+            if (!updatedConfig) {
+              updatedConfig = { collections: {} };
+            }
+            const newVectorConfig: VectorConfigSection = {
+              provider: 'qdrant',
+              url: vectorConfig?.url || 'http://localhost:6333',
+              collection: vectorConfig?.collection || 'nano-brain',
+            };
+            updatedConfig.vector = newVectorConfig;
+            saveCollectionConfig(globalOpts.configPath, updatedConfig);
+            console.log('\n✅ Switched to Qdrant provider');
+          } else {
+            console.log(`\nProvider is currently: ${currentProvider}`);
+            console.log('To use Qdrant for searches, run: npx nano-brain qdrant activate');
+            console.log('Or re-run with: npx nano-brain qdrant migrate --activate');
+          }
+        }
+      }
+      break;
+    }
+
+    case 'activate': {
+      const config = loadCollectionConfig(globalOpts.configPath);
+      const vectorConfig = config?.vector;
+      const qdrantUrl = vectorConfig?.url || 'http://localhost:6333';
+      const resolvedUrl = resolveHostUrl(qdrantUrl);
+
+      try {
+        const healthRes = await fetch(`${resolvedUrl}/healthz`);
+        if (!healthRes.ok) {
+          throw new Error(`HTTP ${healthRes.status}`);
+        }
+      } catch {
+        console.error(`❌ Qdrant is not reachable at ${resolvedUrl}.`);
+        console.error('   Run `npx nano-brain qdrant up` first.');
+        process.exit(1);
+      }
+
+      let updatedConfig = loadCollectionConfig(globalOpts.configPath);
+      if (!updatedConfig) {
+        updatedConfig = { collections: {} };
+      }
+      const newVectorConfig: VectorConfigSection = {
+        provider: 'qdrant',
+        url: qdrantUrl,
+        collection: vectorConfig?.collection || 'nano-brain',
+      };
+      updatedConfig.vector = newVectorConfig;
+      saveCollectionConfig(globalOpts.configPath, updatedConfig);
+
+      console.log('✅ Switched to Qdrant provider');
+      console.log(`   URL: ${qdrantUrl}`);
+      console.log(`   Collection: ${newVectorConfig.collection}`);
+      break;
+    }
+
+    case 'cleanup': {
+      const config = loadCollectionConfig(globalOpts.configPath);
+      const vectorConfig = config?.vector;
+      const currentProvider = vectorConfig?.provider || 'sqlite-vec';
+
+      if (currentProvider !== 'qdrant') {
+        console.error('❌ Cannot cleanup: provider is not set to qdrant');
+        console.error(`   Current provider: ${currentProvider}`);
+        console.error('   Run `npx nano-brain qdrant activate` first.');
+        process.exit(1);
+      }
+
+      const qdrantUrl = vectorConfig?.url || 'http://localhost:6333';
+      const resolvedUrl = resolveHostUrl(qdrantUrl);
+
+      try {
+        const healthRes = await fetch(`${resolvedUrl}/healthz`);
+        if (!healthRes.ok) {
+          throw new Error(`HTTP ${healthRes.status}`);
+        }
+      } catch {
+        console.error(`❌ Qdrant is not reachable at ${resolvedUrl}.`);
+        console.error('   Cannot cleanup without verifying Qdrant has vectors.');
+        process.exit(1);
+      }
+
+      let pointsCount = 0;
+      try {
+        const collectionRes = await fetch(`${resolvedUrl}/collections/nano-brain`);
+        if (collectionRes.ok) {
+          const collectionData = await collectionRes.json();
+          const result = collectionData.result || collectionData;
+          pointsCount = result.points_count ?? result.vectors_count ?? 0;
+        }
+      } catch {
+        console.error('❌ Failed to check Qdrant collection');
+        process.exit(1);
+      }
+
+      if (pointsCount === 0) {
+        console.error('❌ Cannot cleanup: Qdrant collection has no vectors');
+        console.error('   Run `npx nano-brain qdrant migrate` first to migrate vectors.');
+        process.exit(1);
+      }
+
+      console.log(`Qdrant has ${pointsCount} vectors. Proceeding with SQLite cleanup...`);
+
+      const dataDir = DEFAULT_DB_DIR;
+      if (!fs.existsSync(dataDir)) {
+        console.log('No databases found in ' + dataDir);
+        return;
+      }
+
+      const sqliteFiles = fs.readdirSync(dataDir).filter(f => f.endsWith('.sqlite'));
+      if (sqliteFiles.length === 0) {
+        console.log('No SQLite databases found');
+        return;
+      }
+
+      const Database = (await import('better-sqlite3')).default;
+      const sqliteVec = await import('sqlite-vec');
+
+      let cleanedCount = 0;
+      let totalSpaceSaved = 0;
+
+      for (const sqliteFile of sqliteFiles) {
+        const dbPath = path.join(dataDir, sqliteFile);
+        const statBefore = fs.statSync(dbPath);
+        const db = new Database(dbPath);
+
+        try {
+          sqliteVec.load(db);
+        } catch {
+          console.log(`[${sqliteFile}] sqlite-vec not available, skipping`);
+          db.close();
+          continue;
+        }
+
+        let hasVectorTables = false;
+        try {
+          const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name IN ('vectors_vec', 'content_vectors')").all() as Array<{ name: string }>;
+          hasVectorTables = tables.length > 0;
+        } catch {
+          db.close();
+          continue;
+        }
+
+        if (!hasVectorTables) {
+          console.log(`[${sqliteFile}] no vector tables, skipping`);
+          db.close();
+          continue;
+        }
+
+        try {
+          db.exec('DROP TABLE IF EXISTS vectors_vec');
+          db.exec('DELETE FROM content_vectors');
+          db.exec('VACUUM');
+          cleanedCount++;
+
+          const statAfter = fs.statSync(dbPath);
+          const spaceSaved = statBefore.size - statAfter.size;
+          totalSpaceSaved += Math.max(0, spaceSaved);
+
+          console.log(`[${sqliteFile}] cleaned`);
+        } catch (err) {
+          console.error(`[${sqliteFile}] cleanup failed:`, err);
+        }
+
+        db.close();
+      }
+
+      const spaceMB = (totalSpaceSaved / (1024 * 1024)).toFixed(2);
+      console.log(`\n✅ Cleaned ${cleanedCount} database(s), ~${spaceMB} MB freed`);
+      break;
+    }
+
+    default:
+      console.error(`Unknown qdrant subcommand: ${subcommand}`);
+      console.error('Available: up, down, status, migrate, activate, cleanup');
+      process.exit(1);
+  }
+}
+
 async function main() {
   const args = process.argv.slice(2);
   
@@ -1360,6 +1905,8 @@ async function main() {
       return handleImpact(globalOpts, commandArgs);
     case 'logs':
       return handleLogs(commandArgs);
+    case 'qdrant':
+      return handleQdrant(globalOpts, commandArgs);
     default:
       console.error(`Unknown command: ${command}`);
       showHelp();