Capture SDK Overview

import videodb

conn = videodb.connect()

# Create session for a user
cap = conn.create_capture_session(
    end_user_id="user_abc",
    callback_url="https://your-backend.com/webhooks/videodb",
    metadata={"app": "my-ai-copilot"}
)

# Generate token for desktop client (never share API key)
token = conn.generate_client_token(expires_in=600)

# Send session ID and token to desktop client
print(f"Session: {cap.id}, Token: {token}")

import { connect } from 'videodb';

const conn = connect();

// Create session for a user
const cap = await conn.createCaptureSession({
    endUserId: "user_abc",
    callbackUrl: "https://your-backend.com/webhooks/videodb",
    metadata: { app: "my-ai-copilot" }
});

// Generate token for desktop client (never share API key)
const token = await conn.generateClientToken(600);

// Send session ID and token to desktop client
console.log(`Session: ${cap.id}, Token: ${token}`);

import asyncio
from videodb.capture import CaptureClient

async def capture(capture_session_id: str, client_token: str):
    client = CaptureClient(client_token=client_token)

    # Request permissions
    await client.request_permission("microphone")
    await client.request_permission("screen_capture")

    # Discover available sources
    channels = await client.list_channels()
    mic = channels.mics.default
    display = channels.displays.default
    if display:
        display.is_primary = True
    system_audio = channels.system_audio.default
    selected = [c for c in [mic, display, system_audio] if c]

    # Start capture
    await client.start_session(
        capture_session_id=capture_session_id,
        channels=selected,
    )

    # Listen for events
    async for ev in client.events():
        print(f"{ev.event}: {ev.payload}")
        if ev.event in ("recording-complete", "error"):
            break

    await client.stop_session()
    await client.shutdown()

# Run the capture
if __name__ == "__main__":
    asyncio.run(capture(
        capture_session_id="cap-xxx",  # From backend
        client_token="token-xxx"        # From backend
    ))

import { CaptureClient } from 'videodb/capture';

async function capture(captureSessionId, clientToken) {
    const client = new CaptureClient({ sessionToken: clientToken });

    // Request permissions
    await client.requestPermission('microphone');
    await client.requestPermission('screen-capture');

    // Discover available sources
    const channels = await client.listChannels();
    const mic = channels.mics.default;
    const display = channels.displays.default;
    const systemAudio = channels.systemAudio.default;

    const selectedChannels = [mic, display, systemAudio]
        .filter(Boolean)
        .map(c => ({ channelId: c.id, type: c.type, store: true }));

    // Start capture
    await client.startSession({
        sessionId: captureSessionId,
        channels: selectedChannels
    });

    // Listen for events
    client.on('transcript', (data) => console.log(`Transcript: ${data.text}`));
    client.on('recording:stopped', () => client.shutdown());
}

// Run the capture
capture(
    "cap-xxx",      // From backend
    "token-xxx"     // From backend
);

rtstream.start_transcript()
rtstream.index_audio(prompt="Extract key decisions")
rtstream.index_visuals(prompt="Describe what user is doing")
rtstream.search("budget discussion")

await rtstream.startTranscript();
await rtstream.indexAudio({ prompt: "Extract key decisions" });
await rtstream.indexVisuals({ prompt: "Describe what user is doing" });
await rtstream.search({ query: "budget discussion" });