Your App (browser/mobile)
        ↓ WebRTC
LiveKit Server (thinnestAI hosted)
        ↓
Voice Engine: STT → Agent → TTS
        ↓ WebRTC
Audio response streamed back

curl -X POST "https://api.thinnest.ai/v1/voice/session" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "YOUR_AGENT_PUBLIC_ID",
    "metadata": {
      "user_name": "Jane Doe",
      "purpose": "support"
    }
  }'

{
  "session_id": "session_abc123",
  "status": "active",
  "agent_id": "ag_pub_xyz789",
  "web_call_url": "https://app.thinnest.ai/call/session_abc123",
  "token": "eyJhbGciOiJIUzI1NiIs...",
  "livekit_url": "wss://livekit.thinnest.ai",
  "room_name": "api-123-abcde",
  "created_at": "2024-03-01T12:00:00Z",
  "expires_in": 300
}

npm install livekit-client

import { Room, RoomEvent } from 'livekit-client';

// Get token from your backend endpoint that calls thinnestAI API
const { token, livekit_url } = await fetch('/api/start-voice-session', {
  method: 'POST',
}).then(r => r.json());

// Connect to LiveKit room
const room = new Room();
await room.connect(livekit_url, token);

// Publish microphone
const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
const track = stream.getAudioTracks()[0];
await room.localParticipant.publishTrack(track);

// Listen for agent audio
room.on(RoomEvent.TrackSubscribed, (track, publication, participant) => {
  if (track.kind === 'audio') {
    const element = track.attach();
    document.body.appendChild(element);
  }
});

// Disconnect when done
function hangUp() {
  room.disconnect();
}

import { LiveKitRoom, useVoiceAssistant } from '@livekit/components-react';

function VoiceCall({ token, serverUrl }) {
  return (
    <LiveKitRoom token={token} serverUrl={serverUrl} connect={true}>
      <VoiceUI />
    </LiveKitRoom>
  );
}

function VoiceUI() {
  const { state, audioTrack } = useVoiceAssistant();

  return (
    <div>
      <p>Status: {state}</p>
      {audioTrack && <audio autoPlay ref={(el) => {
        if (el) audioTrack.attach(el);
      }} />}
    </div>
  );
}

pip install livekit

import asyncio
from livekit import rtc

async def connect_voice(token: str, url: str):
    room = rtc.Room()
    await room.connect(url, token)

    # Handle incoming audio from agent
    @room.on("track_subscribed")
    def on_track(track, publication, participant):
        if track.kind == rtc.TrackKind.KIND_AUDIO:
            audio_stream = rtc.AudioStream(track)
            # Process audio frames...

    # Publish microphone audio
    source = rtc.AudioSource(sample_rate=16000, num_channels=1)
    track = rtc.LocalAudioTrack.create_audio_track("mic", source)
    await room.local_participant.publish_track(track)

npm install @livekit/react-native

import { Room } from '@livekit/react-native';

const room = new Room();
await room.connect(livekitUrl, token);

// Publish microphone
await room.localParticipant.setMicrophoneEnabled(true);

room.on(RoomEvent.DataReceived, (payload, participant) => {
  const data = JSON.parse(new TextDecoder().decode(payload));

  if (data.type === 'transcript') {
    console.log(`${data.role}: ${data.text}`);
    // role: "user" or "agent"
  }

  if (data.type === 'call_ended') {
    console.log('Call ended, duration:', data.duration);
  }
});

┌──────────────────────────────────┐
│  Your App (Browser/Mobile/IoT)   │
│  LiveKit Client SDK              │
└────────────┬─────────────────────┘
             │ WebRTC (audio + data)
             ▼
┌──────────────────────────────────┐
│  LiveKit Server                  │
│  (thinnestAI hosted)             │
│  - Room management               │
│  - Audio routing                 │
│  - Scaling & load balancing      │
└────────────┬─────────────────────┘
             │
             ▼
┌──────────────────────────────────┐
│  thinnestAI Voice Engine         │
│  - STT (Deepgram / Google)       │
│  - Agent Processing (LLM)        │
│  - TTS (Aero / ElevenLabs / etc) │
│  - Tool execution                │
└──────────────────────────────────┘