Node.js SDK

npm install mikshii-js-sdk

yarn add mikshii-js-sdk

pnpm add mikshii-js-sdk

import { Client } from 'mikshii-js-sdk';

const client = new Client({ apiKey: 'sk_...', baseUrl: 'https://vision.mikshi.ai/dev/' });

git clone <repo-url>
cd nodejs_sdk
npm install            # install runtime dependencies

npm install /absolute/path/to/nodejs_sdk

import { Client } from './src/index.js';

// my-cjs-file.cjs
(async () => {
  const { Client } = await import('mikshii-js-sdk');
  const client = new Client({ apiKey: 'sk_...' });
})();

import { Client, derivedUploadStatus, isPipelineTerminal, isPipelineFailed } from './src/index.js';

const client = new Client({
  apiKey: 'sk_AnFZjh95_...',
  baseUrl: 'https://vision.mikshi.ai/dev/',
});

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

try {
  // 1. Upload — chunks the file, PUTs to S3, completes, and kicks off
  // transcoding + HLS generation. Returns immediately with a video_id.
  const job = await client.uploads.uploadFile('clip.mp4', { name: 'My Clip' });
  console.log(`uploaded ${job.video_id}`);

  // 2. Wait for upload processing (transcode + HLS) to finish.
  while (true) {
    const status = await client.uploads.getStatus(job.video_id);
    const derived = derivedUploadStatus(status);
    if (derived === 'completed') break;
    if (derived === 'failed') throw new Error(status.error_message || 'upload processing failed');
    await sleep(2000);
  }

  // 3. Run analyse + search-process. These two pipelines are what make the
  // video searchable and chat-ready — search/visualize/ask all require them.
  await client.videos.initiateAnalyse(job.video_id);
  await client.videos.initiateSearchProcess(job.video_id);
  while (true) {
    const a = await client.videos.getAnalyseStatus(job.video_id);
    const sp = await client.videos.getSearchProcessStatus(job.video_id);
    if (isPipelineTerminal(a) && isPipelineTerminal(sp)) {
      if (isPipelineFailed(a) || isPipelineFailed(sp)) {
        throw new Error(`pipeline failed: analyse=${a.status}, search=${sp.status}`);
      }
      break;
    }
    await sleep(2000);
  }

  // 4. Vector search — ranked clip-level hits with pre-signed thumbnails and
  // the auth-gated HLS URL for each segment.
  const hits = await client.search.search('person near the door', {
    videoIds: [job.video_id],
    topK: 3,
  });
  for (const hit of hits) {
    console.log(`  #${hit.rank}  [${hit.start} - ${hit.end}]  ${hit.hls_playlist_url}`);
  }

  // 5. Chat — natural-language Q&A over the same video.
  const result = await client.chat.ask('Summarize what happens in the video.', {
    videoId: job.video_id,
  });
  console.log(result.answer);
} finally {
  client.close();
}

import { Client } from './src/index.js';

const client = new Client({
  apiKey: 'sk_...',                              // required
  baseUrl: 'https://vision.mikshi.ai/dev/',      // optional; defaults to http://localhost:8001
  timeout: 30000,                                // optional; per-request timeout in ms
});

import {
  estimateUploadCredits,        // pure helper, no network
  derivedUploadStatus,          // roll the three upload pipelines into one state
  isPipelineDone,
  isPipelineFailed,
  isPipelineTerminal,
} from './src/index.js';

const job = await client.uploads.uploadFile('movie.mp4', { name: 'My Movie' });
console.log(job.video_id);   // poll getStatus(video_id) for processing progress

function onProgress(uploaded, total) {
  console.log(`  ${uploaded}/${total} bytes (${Math.floor((uploaded * 100) / total)}%)`);
}

const job = await client.uploads.uploadFile('movie.mp4', {
  name: 'My Movie',
  chunkSize: 25 * 1024 * 1024,  // 25 MB chunks (default is 10 MB)
  onProgress,
});

const job = await client.uploads.direct('movie.mp4', { name: 'My Movie' });
console.log(job.video_id);

const job = await client.uploads.importYoutube('https://www.youtube.com/watch?v=dQw4w9WgXcQ');

import { YouTubeImportError } from './src/index.js';

try {
  await client.uploads.importYoutube(url);
} catch (e) {
  if (e instanceof YouTubeImportError) {
    console.log(`YouTube import rejected: ${e.code}`);
    if (e.code === 'YOUTUBE_VIDEO_PRIVATE') {
      // skip
    }
  } else {
    throw e;
  }
}

import fs from 'node:fs';
import axios from 'axios';

const init = await client.uploads.initiateMultipart('movie.mp4', 'video/mp4');

const CHUNK = 10 * 1024 * 1024;
const total = fs.statSync('movie.mp4').size;
const parts = [];
const fd = fs.openSync('movie.mp4', 'r');
const buf = Buffer.alloc(CHUNK);

let uploaded = 0;
let partNumber = 1;
while (uploaded < total) {
  const bytesRead = fs.readSync(fd, buf, 0, CHUNK, uploaded);
  if (bytesRead === 0) break;
  const chunk = bytesRead === CHUNK ? buf : buf.subarray(0, bytesRead);
  const p = await client.uploads.getPartUrl(init.s3_object_name, init.upload_id, partNumber);
  const r = await axios.put(p.url, chunk, { timeout: 300000 });
  parts.push({ part_number: partNumber, etag: r.headers.etag.replace(/"/g, '') });
  uploaded += bytesRead;
  partNumber++;
}
fs.closeSync(fd);

await client.uploads.completeMultipart(init.s3_object_name, init.upload_id, parts);
const job = await client.uploads.preprocess(init.s3_object_name, init.video_id, 'My Movie');

import { derivedUploadStatus } from './src/index.js';

while (true) {
  const status = await client.uploads.getStatus(job.video_id);
  const derived = derivedUploadStatus(status);
  if (derived === 'completed' || derived === 'failed') {
    if (derived === 'failed') throw new Error(status.error_message || 'processing failed');
    break;
  }
  console.log(
    `  transcode=${status.transcoding_status?.percentage ?? 0}%  ` +
    `hls=${status.hls_generation_status?.percentage ?? 0}%`,
  );
  await new Promise((r) => setTimeout(r, 2000));
}

// List with filters (only set what you need)
const videos = await client.videos.list({ status: 'processed', limit: 50, sortOrder: 'asc' });

// Single-video details (includes video_metadata)
const details = await client.videos.get(videoId);
console.log(details.name, details.video_metadata);

// Kick off the analyse pipeline, then poll
await client.videos.initiateAnalyse(videoId);
while (true) {
  const s = await client.videos.getAnalyseStatus(videoId);
  if (isPipelineTerminal(s)) break;
  console.log(`  analyse ${s.percentage ?? 0}%`);
  await sleep(2000);
}

// Permanent delete (also removes derived S3 assets)
await client.videos.delete(videoId);

const result = await client.chat.ask('Describe what happens in this video.', {
  videoId: 'a249266f-052d-4148-bc2f-3efa76dc4269',
});
console.log(result.answer);

const VIDEO_ID = 'a249266f-052d-4148-bc2f-3efa76dc4269';
const history = [];

async function turn(question) {
  const result = await client.chat.ask(question, { videoId: VIDEO_ID, history });
  history.push({ role: 'user', content: question });
  history.push({ role: 'assistant', content: result.answer });
  return result.answer;
}

console.log(await turn('Describe what happens in this video.'));
console.log(await turn('How many people are involved?'));
console.log(await turn('What was my first question?'));

await client.chat.ask('Walk me through every event in chronological order.', {
  videoId: VIDEO_ID,
  topK: 20,
});

for await (const ev of client.chat.askStream('How many people are involved?', {
  videoId: VIDEO_ID,
})) {
  if (ev.event === 'token') {
    process.stdout.write(ev.data.content);
  } else if (ev.event === 'done') {
    console.log();                     // full answer is also on ev.data.answer
  } else if (ev.event === 'error') {
    console.log(`\n[error] ${ev.data.detail}`);
    break;
  }
}

const hits = await client.search.search('person walking near the gate', {
  videoIds: ['b2f1...-1111', 'b2f1...-2222'],
  topK: 5,
});

for (const hit of hits) {
  console.log(
    `#${hit.rank}  [${hit.start} - ${hit.end}]  video=${hit.video_id}\n` +
    `    hls:   ${hit.hls_playlist_url}\n` +
    `    thumb: ${hit.thumbnail_url}`,
  );
}

const hits = await client.search.search('forklift incident', { collectionId: coll.collection_id });

const viz = await client.search.visualize({ collectionId: '3fa8...' });

console.log(Object.keys(viz.videos).length, 'videos,', viz.points.length, 'points');

for (const [videoId, info] of Object.entries(viz.videos)) {
  console.log(videoId, 'color=', info.color);
}

for (const p of viz.points.slice(0, 5)) {
  console.log(`  (${p.x.toFixed(4)}, ${p.y.toFixed(4)})  segment=${p.segment_id}  start=${p.start}`);
}

{
  "videos": {
    "<video_id>": {
      "video_id": "uuid",
      "color": "hsl(217, 70%, 55%)",
      "hls_playlist_url": "...",
      "video_url": "..."
    }
  },
  "points": [
    {
      "segment_id": "uuid",
      "video_id": "uuid",
      "x": 0.41,    // 0.0 - 1.0
      "y": 0.78,
      "start": "00:00:00",
      "end":   "00:00:06",
      "thumbnail_url": "..."
    }
  ]
}

const resp = await client.embeddings.video('a249266f-052d-4148-bc2f-3efa76dc4269');

console.log(resp.status, resp.id, resp.data.length, 'segments');
for (const seg of resp.data) {
  console.log(
    `  [${seg.start} - ${seg.end}]  ` +
    `option=${seg.embedding_option}  scope=${seg.embedding_scope}  ` +
    `dims=${seg.embedding.length}`,
  );
}

const resp = await client.embeddings.text('chain wearing man');
const [vector] = resp.data;
console.log(`dims=${vector.embedding.length}  status=${resp.status}`);

import crypto from 'node:crypto';
import { Pinecone } from '@pinecone-database/pinecone';

const NAMESPACE_URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; // RFC-4122 URL namespace
const uuid5 = (name) => {
  const hash = crypto.createHash('sha1').update(
    Buffer.concat([Buffer.from(NAMESPACE_URL.replaceAll('-', ''), 'hex'), Buffer.from(name)]),
  ).digest();
  hash[6] = (hash[6] & 0x0f) | 0x50;
  hash[8] = (hash[8] & 0x3f) | 0x80;
  const h = hash.toString('hex');
  return `${h.slice(0,8)}-${h.slice(8,12)}-${h.slice(12,16)}-${h.slice(16,20)}-${h.slice(20,32)}`;
};

const pc = new Pinecone({ apiKey: '...' });
const index = pc.Index('video-segments');

// 1. Ingest — pull segment embeddings from our SDK, upsert into Pinecone.
const resp = await client.embeddings.video(videoId);
await index.upsert(resp.data.map((seg) => ({
  id: uuid5(`${resp.id}|${seg.start}|${seg.end}`),
  values: seg.embedding,
  metadata: { video_id: resp.id, start: seg.start, end: seg.end },
})));

// 2. Query — embed the user's text with our SDK, search Pinecone.
const query = await client.embeddings.text('man wearing striped shirt');
const [qv] = query.data;
const hits = await index.query({ vector: qv.embedding, topK: 5, includeMetadata: true });
for (const m of hits.matches) {
  console.log(m.score, m.metadata.video_id, m.metadata.start);
}

import { QdrantClient } from '@qdrant/js-client-rest';

const qd = new QdrantClient({ url: 'http://localhost:6333' });
await qd.recreateCollection('video-segments', {
  vectors: { size: 1024, distance: 'Cosine' },
});

// 1. Ingest.
const resp = await client.embeddings.video(videoId);
await qd.upsert('video-segments', {
  points: resp.data.map((seg) => ({
    id: uuid5(`${resp.id}|${seg.start}|${seg.end}`),
    vector: seg.embedding,
    payload: { video_id: resp.id, start: seg.start, end: seg.end },
  })),
});

// 2. Query.
const query = await client.embeddings.text('man wearing striped shirt');
const [qv] = query.data;
const hits = await qd.search('video-segments', {
  vector: qv.embedding,
  limit: 5,
  with_payload: true,
});
for (const h of hits) {
  console.log(h.score, h.payload.video_id, h.payload.start);
}

import weaviate from 'weaviate-client';

const wv = await weaviate.connectToLocal();
await wv.collections.create({
  name: 'VideoSegment',
  vectorizers: weaviate.configure.vectorizer.none(),
  properties: [
    { name: 'video_id', dataType: 'text' },
    { name: 'start',    dataType: 'text' },
    { name: 'end',      dataType: 'text' },
  ],
});
const coll = wv.collections.get('VideoSegment');

// 1. Ingest — Weaviate accepts our vector directly.
const resp = await client.embeddings.video(videoId);
await coll.data.insertMany(resp.data.map((seg) => ({
  properties: { video_id: resp.id, start: seg.start, end: seg.end },
  vectors: seg.embedding,
})));

// 2. Query.
const query = await client.embeddings.text('man wearing striped shirt');
const [qv] = query.data;
const results = await coll.query.nearVector(qv.embedding, { limit: 5 });
for (const obj of results.objects) {
  console.log(obj.metadata?.distance, obj.properties.video_id, obj.properties.start);
}

import pg from 'pg';
import pgvector from 'pgvector/pg';

const conn = new pg.Client({ connectionString: 'postgres://localhost/video' });
await conn.connect();
await pgvector.registerType(conn);

await conn.query(`
  CREATE TABLE IF NOT EXISTS video_segments (
    segment_id uuid PRIMARY KEY,
    video_id   uuid NOT NULL,
    start_ts   text NOT NULL,
    end_ts     text NOT NULL,
    embedding  vector(1024)
  );
  CREATE INDEX IF NOT EXISTS video_segments_vec_idx
    ON video_segments USING hnsw (embedding vector_cosine_ops);
`);

// 1. Ingest.
const resp = await client.embeddings.video(videoId);
for (const seg of resp.data) {
  await conn.query(
    `INSERT INTO video_segments (segment_id, video_id, start_ts, end_ts, embedding)
     VALUES ($1, $2, $3, $4, $5)
     ON CONFLICT (segment_id) DO UPDATE SET embedding = EXCLUDED.embedding`,
    [
      uuid5(`${resp.id}|${seg.start}|${seg.end}`),
      resp.id,
      seg.start,
      seg.end,
      pgvector.toSql(seg.embedding),
    ],
  );
}

// 2. Query — `<=>` is cosine distance (smaller = closer).
const query = await client.embeddings.text('man wearing striped shirt');
const [qv] = query.data;
const v = pgvector.toSql(qv.embedding);
const { rows } = await conn.query(
  `SELECT segment_id, video_id, start_ts, end_ts, embedding <=> $1 AS distance
   FROM video_segments
   ORDER BY embedding <=> $1
   LIMIT 5`,
  [v],
);
for (const row of rows) console.log(row.distance, row.video_id, row.start_ts);

async function hitToPlayable(videoId, start) {
  const details = await client.videos.get(videoId);
  return `${details.hls_playlist_path}#t=${start}`;
}

import { Client, ConflictError, RateLimitError } from './src/index.js';

try {
  await client.collections.create('already-taken');
} catch (e) {
  if (e instanceof ConflictError) {
    console.log('name is taken');
  } else if (e instanceof RateLimitError) {
    if (e.retryAfter) await new Promise((r) => setTimeout(r, e.retryAfter * 1000));
  } else {
    throw e;
  }
}

{ "video_id": "uuid" }

{
  "video_id": "uuid",
  "thumbnail_generation_status": { "status": "completed", "percentage": 100, "error": null },
  "transcoding_status":          { "status": "in_progress", "percentage": 42, "error": null },
  "hls_generation_status":       { "status": "pending", "percentage": 0, "error": null },
  "error_message": null
}

// initiateMultipart
{ "upload_id": "string", "s3_object_name": "string", "video_id": "uuid" }

// getPartUrl
{ "url": "https://s3...", "part_number": 1 }

// listParts → array of:
{ "part_number": 1, "etag": "string" }

// completeMultipart
{ "s3_object_name": "string", "upload_id": "string", "etag": "string" }

{
  "video_id": "uuid",
  "name": "string",
  "status": "PROCESSED",
  "video_path": "...signed...",
  "thumbnail_path": "...signed...",
  "hls_playlist_path": "...auth-gated proxy...",
  "transcoding_status": "completed",
  "hls_generation_status": "completed",
  "thumbnail_generation_status": "completed",
  "analyse_status": "done",        // list only
  "search_process_status": "done", // list only
  "video_metadata": { "...": "..." }, // get only
  "created_at": "ISO-8601"
}

// initiateSearchProcess / initiateAnalyse
{ "video_id": "uuid", "status": "enqueued" }

// getSearchProcessStatus / getAnalyseStatus
{ "video_id": "uuid", "status": "done", "percentage": 100, "error": null }

{
  "data": [
    {
      "collection_id": "uuid",
      "name": "string",
      "description": "string | null",
      "parent_id": "uuid",
      "parent_type": "user",
      "created_at": "ISO-8601",
      "video_count": 0,
      "thumbnails": ["url", "..."]
    }
  ],
  "page": 1,
  "page_size": 10,
  "total": 47
}

{ "answer": "string" }

{
  "rank": 1,
  "start": "00:00:12",
  "end":   "00:00:18",
  "video_id": "uuid",
  "thumbnail_url": "...signed...",
  "hls_playlist_url": "...auth-gated...",
  "video_url": "...signed..."
}

{
  "id": "uuid",
  "status": "ready",
  "data": [
    {
      "embedding": [/* 1024 floats */],
      "embedding_option": "visual",
      "embedding_scope":  "clip",
      "start": "HH:MM:SS",
      "end":   "HH:MM:SS"
    }
  ]
}

{
  "status": "ready",
  "data": [ { "embedding": [/* 1024 floats */] } ]
}

import { Client } from './src/index.js';
const client = new Client({ apiKey: 'sk_...', baseUrl: 'https://vision.mikshi.ai/dev/' });

import { derivedUploadStatus } from './src/index.js';

async function uploadAndWait(path, name, pollInterval = 2000) {
  const job = await client.uploads.uploadFile(path, { name });
  console.log(`queued ${job.video_id}`);

  while (true) {
    const status = await client.uploads.getStatus(job.video_id);
    const derived = derivedUploadStatus(status);
    if (derived === 'completed') break;
    if (derived === 'failed') throw new Error(`upload failed: ${status.error_message}`);
    console.log(
      `  transcode=${status.transcoding_status?.percentage ?? 0}%  ` +
      `hls=${status.hls_generation_status?.percentage ?? 0}%`,
    );
    await new Promise((r) => setTimeout(r, pollInterval));
  }

  return await client.videos.get(job.video_id);
}

const video = await uploadAndWait('clip.mp4', 'My Clip');
console.log('HLS playlist:', video.hls_playlist_path);

import fs from 'node:fs';
import path from 'node:path';
import axios from 'axios';

const CHUNK = 10 * 1024 * 1024;
const STATE_FILE = '.upload-state.json';

async function resumeOrStart(localPath, name) {
  let state;
  if (fs.existsSync(STATE_FILE)) {
    state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
    console.log(`resuming upload ${state.upload_id}`);
  } else {
    const init = await client.uploads.initiateMultipart(path.basename(localPath), 'video/mp4');
    state = {
      upload_id: init.upload_id,
      s3_object_name: init.s3_object_name,
      video_id: init.video_id,
    };
    fs.writeFileSync(STATE_FILE, JSON.stringify(state));
  }

  const already = await client.uploads.listParts(state.s3_object_name, state.upload_id);
  const done = new Set(already.map((p) => p.part_number));
  const parts = [...already];

  const total = fs.statSync(localPath).size;
  const fd = fs.openSync(localPath, 'r');
  const buf = Buffer.alloc(CHUNK);
  let uploaded = 0, partNumber = 1;
  while (uploaded < total) {
    const bytesRead = fs.readSync(fd, buf, 0, CHUNK, uploaded);
    if (bytesRead === 0) break;
    if (!done.has(partNumber)) {
      const chunk = bytesRead === CHUNK ? buf : buf.subarray(0, bytesRead);
      const p = await client.uploads.getPartUrl(state.s3_object_name, state.upload_id, partNumber);
      const r = await axios.put(p.url, chunk, { timeout: 300000 });
      parts.push({ part_number: partNumber, etag: r.headers.etag.replace(/"/g, '') });
    }
    uploaded += bytesRead;
    partNumber++;
  }
  fs.closeSync(fd);

  parts.sort((a, b) => a.part_number - b.part_number);
  await client.uploads.completeMultipart(state.s3_object_name, state.upload_id, parts);
  const job = await client.uploads.preprocess(state.s3_object_name, state.video_id, name);
  fs.unlinkSync(STATE_FILE);
  return job;
}

await resumeOrStart('big-movie.mp4', 'Big Movie');

import { YouTubeImportError } from './src/index.js';

async function safeYoutubeImport(url) {
  try {
    return await client.uploads.importYoutube(url);
  } catch (e) {
    if (e instanceof YouTubeImportError) {
      if (e.code === 'YOUTUBE_VIDEO_PRIVATE') {
        console.log('video is private, skipping');
        return null;
      }
      if (e.code === 'YOUTUBE_VIDEO_AGE_RESTRICTED') {
        console.log('age-restricted, skipping');
        return null;
      }
    }
    throw e;
  }
}

async function backfillPipelines() {
  const all = await client.videos.list({ limit: 500 });
  const pending = all.filter(
    (v) =>
      v.transcoding_status === 'completed' &&
      (v.analyse_status !== 'done' || v.search_process_status !== 'done'),
  );
  console.log(`backfilling ${pending.length} videos`);

  await Promise.all(pending.map(async (v) => {
    if (v.analyse_status !== 'done') await client.videos.initiateAnalyse(v.video_id);
    if (v.search_process_status !== 'done') await client.videos.initiateSearchProcess(v.video_id);
  }));

  return pending.map((v) => v.video_id);
}

await backfillPipelines();

async function* recentVideos(limitPerCall = 100) {
  const weekAgo = new Date(Date.now() - 7 * 24 * 3600 * 1000);
  let skip = 0;
  while (true) {
    const batch = await client.videos.list({
      startTime: weekAgo,
      sortBy: 'created_at',
      sortOrder: 'desc',
      skip,
      limit: limitPerCall,
    });
    if (batch.length === 0) return;
    for (const v of batch) yield v;
    if (batch.length < limitPerCall) return;
    skip += limitPerCall;
  }
}

for await (const video of recentVideos()) {
  console.log(video.video_id, video.name, video.created_at);
}

import fs from 'node:fs';
import path from 'node:path';
import { isPipelineTerminal, isPipelineFailed } from './src/index.js';

async function waitPipelines(videoId) {
  await client.videos.initiateAnalyse(videoId);
  await client.videos.initiateSearchProcess(videoId);
  while (true) {
    const a  = await client.videos.getAnalyseStatus(videoId);
    const sp = await client.videos.getSearchProcessStatus(videoId);
    if (isPipelineTerminal(a) && isPipelineTerminal(sp)) {
      if (isPipelineFailed(a) || isPipelineFailed(sp)) {
        throw new Error(`pipeline failed: analyse=${a.status}, search=${sp.status}`);
      }
      return;
    }
    await new Promise((r) => setTimeout(r, 2000));
  }
}

async function bulkUploadToCollection(folder, collectionName) {
  const coll = await client.collections.create(collectionName);
  console.log(`created collection ${coll.collection_id}`);

  const files = fs.readdirSync(folder).filter((f) => f.endsWith('.mp4')).sort();
  for (const file of files) {
    const video = await uploadAndWait(path.join(folder, file), path.parse(file).name);
    await waitPipelines(video.video_id);
    await client.collections.addVideo(coll.collection_id, video.video_id);
    console.log(`  added ${file}`);
  }

  return coll;
}

await bulkUploadToCollection('./footage', 'Warehouse - April');

import { RateLimitError, ConflictError } from './src/index.js';

async function withRetries(call, { retries = 5 } = {}) {
  for (let attempt = 0; attempt < retries; attempt++) {
    try {
      return await call();
    } catch (e) {
      if (!(e instanceof RateLimitError)) throw e;
      const wait = (e.retryAfter ?? Math.pow(2, attempt)) * 1000;
      console.log(`rate limited, sleeping ${wait}ms`);
      await new Promise((r) => setTimeout(r, wait));
    }
  }
  throw new Error('retries exhausted');
}

async function getOrCreateCollection(name) {
  try {
    return await withRetries(() => client.collections.create(name));
  } catch (e) {
    if (!(e instanceof ConflictError)) throw e;
    const page = await client.collections.list({ page: 1, pageSize: 100 });
    const found = page.data.find((c) => c.name === name);
    if (found) return found;
    throw e;
  }
}

async function* allCollections(pageSize = 100) {
  let page = 1, yielded = 0;
  while (true) {
    const result = await client.collections.list({ page, pageSize });
    if (result.data.length === 0) return;
    for (const c of result.data) {
      yield c;
      yielded++;
    }
    if (yielded >= result.total) return;
    page++;
  }
}

class Conversation {
  constructor(client, { videoId, topK = null } = {}) {
    this.client = client;
    this.videoId = videoId;
    this.topK = topK;
    this.history = [];
  }

  async ask(question) {
    const result = await this.client.chat.ask(question, {
      videoId: this.videoId,
      topK: this.topK,
      history: this.history,
    });
    this.history.push({ role: 'user', content: question });
    this.history.push({ role: 'assistant', content: result.answer });
    return result.answer;
  }
}

const chat = new Conversation(client, { videoId: 'a249266f-052d-4148-bc2f-3efa76dc4269' });
console.log(await chat.ask('Describe what happens.'));
console.log(await chat.ask('How many people are involved?'));
console.log(await chat.ask('What was my first question?'));

const hits = await client.search.search('package being dropped', {
  collectionId: coll.collection_id,
  topK: 10,
});
if (hits.length === 0) {
  console.log('no matches');
} else {
  const top = hits[0];
  console.log(`open ${top.hls_playlist_url}#t=${top.start}`);
}

async function groupedVisualization(collectionId) {
  const viz = await client.search.visualize({ collectionId });
  const byVideo = new Map();
  for (const point of viz.points) {
    if (!byVideo.has(point.video_id)) byVideo.set(point.video_id, []);
    byVideo.get(point.video_id).push(point);
  }
  for (const [videoId, points] of byVideo) {
    const info = viz.videos[videoId];
    console.log(`${videoId}  color=${info.color}  segments=${points.length}`);
  }
  return { viz, byVideo };
}

await groupedVisualization(coll.collection_id);

npm install
node --check src/index.js   # quick syntax check

export VIDEOSDK_API_KEY=sk_...
export VIDEOSDK_BASE_URL=https://vision.mikshi.ai/dev/
node examples/collections/list_collections.js

$env:VIDEOSDK_API_KEY = "sk_..."
$env:VIDEOSDK_BASE_URL = "https://vision.mikshi.ai/dev/"
node examples/collections/list_collections.js