Building a Video Chat App

# Browser - no extra dependencies needed
npm install @nolag/js-sdk

# Node.js - requires wrtc package
npm install @nolag/js-sdk wrtc

// When creating a room via the REST API, enable WebRTC topics
const response = await fetch('https://api.nolag.io/rooms', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer your_api_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    appId: 'your_app_id',
    slug: 'meeting-123',
    enableWebRTC: true  // This adds webrtc:offer, webrtc:answer, webrtc:candidate topics
  })
})

import { NoLag, WebRTCManager } from '@nolag/js-sdk'

// Connect to NoLag
const client = NoLag('your_access_token')
await client.connect()

// Initialize WebRTC manager
const webrtc = new WebRTCManager(client, {
  app: 'video-chat',
  room: 'meeting-123',
  iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
})

// Get local media
const localStream = await navigator.mediaDevices.getUserMedia({
  video: true,
  audio: true
})

// Display local video
const localVideo = document.getElementById('local-video')
localVideo.srcObject = localStream

// Set the local stream for WebRTC
webrtc.setLocalStream(localStream)

// Start WebRTC (subscribes to signaling, discovers peers)
await webrtc.start()

// Handle remote peer connections
webrtc.on('peerConnected', (actorId, remoteStream) => {
  console.log('Peer connected:', actorId)

  // Create video element for remote peer
  const video = document.createElement('video')
  video.id = `video-${actorId}`
  video.srcObject = remoteStream
  video.autoplay = true
  video.playsInline = true

  document.getElementById('remote-videos').appendChild(video)
})

webrtc.on('peerDisconnected', (actorId) => {
  console.log('Peer disconnected:', actorId)

  // Remove video element
  const video = document.getElementById(`video-${actorId}`)
  video?.remove()
})

// Handle individual tracks
webrtc.on('peerTrack', (actorId, track, stream) => {
  console.log(`Received ${track.kind} track from ${actorId}`)
})

// Handle errors
webrtc.on('error', (error) => {
  console.error('WebRTC error:', error)
})

// Clean up when leaving the call
function leaveCall() {
  // Stop WebRTC manager
  webrtc.stop()

  // Stop local media tracks
  localStream.getTracks().forEach(track => track.stop())

  // Disconnect from NoLag (optional)
  client.disconnect()
}

// Handle page unload
window.addEventListener('beforeunload', leaveCall)

# Basic WebRTC setup in Python
# First: pip install nolag[webrtc]

from nolag import NoLag, WebRTCManager
import asyncio

async def main():
    # Connect to NoLag
    client = NoLag('your_access_token')
    await client.connect()

    # Initialize WebRTC manager
    webrtc = WebRTCManager(
        client,
        app='video-chat',
        room='meeting-123',
        ice_servers=[
            {'urls': 'stun:stun.l.google.com:19302'},
            {'urls': 'stun:stun1.l.google.com:19302'}
        ]
    )

    # Handle peer connections
    @webrtc.on('peer_connected')
    async def on_peer(actor_id, track):
        print(f'Peer {actor_id} connected with {track.kind} track')

    @webrtc.on('peer_disconnected')
    def on_disconnect(actor_id):
        print(f'Peer {actor_id} disconnected')

    # Start WebRTC
    await webrtc.start()
    print('WebRTC is ready!')

    # Keep running
    try:
        await asyncio.Event().wait()
    except KeyboardInterrupt:
        await webrtc.stop()
        await client.disconnect()

asyncio.run(main())

# AI Voice Bot with WebRTC in Python
# pip install nolag[webrtc] anthropic

from nolag import NoLag, WebRTCManager
import anthropic
import asyncio

client_anthropic = anthropic.Anthropic()

async def process_audio_frame(frame):
    """Process audio frame from WebRTC"""
    # Convert frame to audio samples
    samples = frame.to_ndarray()
    # Send to speech-to-text service
    return samples

async def get_claude_response(text: str) -> str:
    """Send user speech to Claude and get response"""
    response = client_anthropic.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{"role": "user", "content": text}]
    )
    return response.content[0].text

async def main():
    # Connect to NoLag
    client = NoLag('bot_access_token')
    await client.connect()

    # Initialize WebRTC manager
    webrtc = WebRTCManager(
        client,
        app='video-chat',
        room='meeting-123'
    )

    # Handle incoming audio from peers
    @webrtc.on('peer_connected')
    async def on_peer(actor_id, track):
        print(f'User connected: {actor_id}')

        if track.kind == 'audio':
            audio_buffer = []

            while True:
                try:
                    frame = await track.recv()
                    samples = await process_audio_frame(frame)
                    audio_buffer.append(samples)

                    # Process when we have enough audio
                    if len(audio_buffer) > 50:  # ~1 second of audio
                        # 1. Speech-to-text
                        user_text = await speech_to_text(audio_buffer)
                        audio_buffer.clear()

                        if user_text:
                            print(f'User said: {user_text}')

                            # 2. Get Claude response
                            response = await get_claude_response(user_text)
                            print(f'Bot: {response}')

                            # 3. Text-to-speech and send back
                            # await send_audio_response(response)

                except Exception as e:
                    print(f'Error: {e}')
                    break

    @webrtc.on('peer_disconnected')
    def on_disconnect(actor_id):
        print(f'User disconnected: {actor_id}')

    # Start the bot
    await webrtc.start()
    print('AI Voice Bot is ready!')

    await asyncio.Event().wait()

asyncio.run(main())

// Basic WebRTC setup in Go
// go get github.com/NoLagApp/nolag-go

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"

    "github.com/NoLagApp/nolag-go"
    "github.com/pion/webrtc/v3"
)

func main() {
    // Connect to NoLag
    client := nolag.New("your_access_token")
    if err := client.Connect(); err != nil {
        panic(err)
    }
    defer client.Close()

    // Initialize WebRTC manager
    webrtcMgr := nolag.NewWebRTCManager(client, nolag.WebRTCOptions{
        App:  "video-chat",
        Room: "meeting-123",
        ICEServers: []webrtc.ICEServer{
            {URLs: []string{"stun:stun.l.google.com:19302"}},
            {URLs: []string{"stun:stun1.l.google.com:19302"}},
        },
    })

    // Handle incoming tracks from peers
    webrtcMgr.OnTrack(func(actorID string, track *webrtc.TrackRemote, receiver *webrtc.RTPReceiver) {
        fmt.Printf("Peer %s connected with %s track
", actorID, track.Kind())

        // Process the track in a goroutine
        go func() {
            for {
                packet, _, err := track.ReadRTP()
                if err != nil {
                    return
                }
                // Process packet.Payload
                _ = packet
            }
        }()
    })

    // Handle peer disconnection
    webrtcMgr.On(nolag.EventPeerDisconnected, func(args ...any) {
        actorID := args[0].(string)
        fmt.Printf("Peer %s disconnected
", actorID)
    })

    // Start WebRTC
    if err := webrtcMgr.Start(); err != nil {
        panic(err)
    }
    fmt.Println("WebRTC is ready!")

    // Wait for shutdown signal
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
    <-sigChan

    webrtcMgr.Stop()
    fmt.Println("Shutdown complete")
}

// AI Voice Bot with WebRTC in Go
// go get github.com/NoLagApp/nolag-go
// go get github.com/anthropics/anthropic-sdk-go

package main

import (
    "context"
    "fmt"

    "github.com/NoLagApp/nolag-go"
    "github.com/anthropics/anthropic-sdk-go"
    "github.com/pion/webrtc/v3"
)

var anthropicClient *anthropic.Client

func init() {
    anthropicClient = anthropic.NewClient()
}

func getCloudeResponse(text string) (string, error) {
    resp, err := anthropicClient.Messages.Create(context.Background(), anthropic.MessageCreateParams{
        Model:     anthropic.ModelClaudeSonnet4_20250514,
        MaxTokens: 1024,
        Messages: []anthropic.MessageParam{
            anthropic.NewUserMessage(anthropic.NewTextBlock(text)),
        },
    })
    if err != nil {
        return "", err
    }
    return resp.Content[0].Text, nil
}

func main() {
    // Connect to NoLag
    client := nolag.New("bot_access_token")
    if err := client.Connect(); err != nil {
        panic(err)
    }
    defer client.Close()

    // Initialize WebRTC manager
    webrtcMgr := nolag.NewWebRTCManager(client, nolag.WebRTCOptions{
        App:  "video-chat",
        Room: "meeting-123",
    })

    // Handle incoming audio from peers
    webrtcMgr.OnTrack(func(actorID string, track *webrtc.TrackRemote, receiver *webrtc.RTPReceiver) {
        fmt.Printf("User connected: %s
", actorID)

        if track.Kind() == webrtc.RTPCodecTypeAudio {
            go func() {
                audioBuffer := make([]byte, 0)

                for {
                    packet, _, err := track.ReadRTP()
                    if err != nil {
                        return
                    }

                    audioBuffer = append(audioBuffer, packet.Payload...)

                    // Process when we have enough audio (~1 second)
                    if len(audioBuffer) > 48000 {
                        // 1. Speech-to-text
                        userText := speechToText(audioBuffer)
                        audioBuffer = make([]byte, 0)

                        if userText != "" {
                            fmt.Printf("User said: %s
", userText)

                            // 2. Get Claude response
                            response, err := getCloudeResponse(userText)
                            if err != nil {
                                fmt.Printf("Error: %v
", err)
                                continue
                            }
                            fmt.Printf("Bot: %s
", response)

                            // 3. Text-to-speech and send back
                            // sendAudioResponse(response)
                        }
                    }
                }
            }()
        }
    })

    webrtcMgr.On(nolag.EventPeerDisconnected, func(args ...any) {
        actorID := args[0].(string)
        fmt.Printf("User disconnected: %s
", actorID)
    })

    // Start the bot
    if err := webrtcMgr.Start(); err != nil {
        panic(err)
    }
    fmt.Println("AI Voice Bot is ready!")

    select {}
}

// AI Voice Bot with WebRTC in Node.js
// First: npm install @nolag/js-sdk wrtc

import { NoLag, WebRTCManager } from '@nolag/js-sdk'
import { nonstandard } from 'wrtc'

const { RTCAudioSink } = nonstandard

// Connect to NoLag
const client = NoLag('bot_access_token')
await client.connect()

// Initialize WebRTC manager (wrtc is detected automatically)
const webrtc = new WebRTCManager(client, {
  app: 'video-chat',
  room: 'meeting-123'
})

// Handle incoming audio from peers
webrtc.on('peerConnected', (actorId, remoteStream) => {
  console.log('User connected:', actorId)

  // Get audio track from the remote stream
  const audioTrack = remoteStream.getAudioTracks()[0]
  if (audioTrack) {
    // Create audio sink to receive raw audio data
    const sink = new RTCAudioSink(audioTrack)

    sink.ondata = (data) => {
      // data.samples contains Int16Array audio samples
      // Send to speech-to-text service (Whisper, Deepgram, etc.)
      processAudioWithSTT(data.samples)
    }
  }
})

webrtc.on('peerDisconnected', (actorId) => {
  console.log('User disconnected:', actorId)
})

// Start the bot
await webrtc.start()
console.log('AI Voice Bot is ready!')

// Complete AI Voice Bot flow
import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic()

// Accumulate audio chunks for processing
let audioBuffer: Int16Array[] = []
let silenceTimeout: NodeJS.Timeout | null = null

async function processAudioWithSTT(samples: Int16Array) {
  audioBuffer.push(samples)

  // Reset silence detection timer
  if (silenceTimeout) clearTimeout(silenceTimeout)

  // After 500ms of silence, process the audio
  silenceTimeout = setTimeout(async () => {
    if (audioBuffer.length === 0) return

    // Combine audio chunks
    const combinedAudio = combineAudioChunks(audioBuffer)
    audioBuffer = []

    // 1. Speech-to-Text (using your preferred service)
    const userText = await speechToText(combinedAudio)
    console.log('User said:', userText)

    // 2. Send to Claude for response
    const response = await anthropic.messages.create({
      model: 'claude-sonnet-4-20250514',
      max_tokens: 1024,
      messages: [{ role: 'user', content: userText }]
    })

    const botResponse = response.content[0].text
    console.log('Bot response:', botResponse)

    // 3. Text-to-Speech (ElevenLabs, OpenAI TTS, etc.)
    const audioResponse = await textToSpeech(botResponse)

    // 4. Send audio back through WebRTC
    await sendAudioToPeers(audioResponse)
  }, 500)
}

const webrtc = new WebRTCManager(client, {
  app: 'video-chat',
  room: 'meeting-123',
  iceServers: [
    { urls: 'stun:stun.l.google.com:19302' },
    {
      urls: 'turn:your-turn-server.com:3478',
      username: 'your-username',
      credential: 'your-credential'
    }
  ]
})