Build a backend and client from scratch

// app/api/token/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { RtcTokenBuilder, RtcRole, RtmTokenBuilder } from 'agora-token';

const APP_ID = process.env.NEXT_PUBLIC_AGORA_APP_ID!;
const APP_CERTIFICATE = process.env.NEXT_AGORA_APP_CERTIFICATE!;
const TOKEN_TTL_SECONDS = 60 * 60; // 1 hour

export async function POST(req: NextRequest) {
  const { channel, uid } = await req.json();
  if (!channel || typeof uid !== 'number') {
    return NextResponse.json({ error: 'channel and numeric uid required' }, { status: 400 });
  }

  const expireAt = Math.floor(Date.now() / 1000) + TOKEN_TTL_SECONDS;

  const rtcToken = RtcTokenBuilder.buildTokenWithUid(
    APP_ID,
    APP_CERTIFICATE,
    channel,
    uid,
    RtcRole.PUBLISHER,
    expireAt,
    expireAt,
  );
  const rtmToken = RtmTokenBuilder.buildToken(
    APP_ID,
    APP_CERTIFICATE,
    String(uid),
    expireAt,
  );

  return NextResponse.json({ rtcToken, rtmToken, expireAt });
}

// app/api/invite-agent/route.ts
import { NextRequest, NextResponse } from 'next/server';
import {
  AgoraClient,
  Agent,
  Area,
  DeepgramSTT,
  ExpiresIn,
  MiniMaxTTS,
  OpenAI,
} from 'agora-agents';

const client = new AgoraClient({
  area: Area.US,
  appId: process.env.NEXT_PUBLIC_AGORA_APP_ID!,
  appCertificate: process.env.NEXT_AGORA_APP_CERTIFICATE!,
});

const AGENT_UID = 123456;

export async function POST(req: NextRequest) {
  const { channel } = await req.json();
  if (!channel) {
    return NextResponse.json({ error: 'channel required' }, { status: 400 });
  }

  const agent = new Agent({
    client,
    instructions: 'You are a friendly support agent for Acme Corp. Keep answers under 30 seconds.',
    greeting: 'Hi there! How can I help you today?',
    failureMessage: 'Sorry, I had trouble hearing that. Could you repeat?',
    maxHistory: 50,
    advancedFeatures: { enable_rtm: true, enable_tools: false },
    parameters: { data_channel: 'rtm', enable_error_message: true },
  })
    .withStt(new DeepgramSTT({ model: 'nova-3', language: 'en' }))
    .withLlm(new OpenAI({ model: 'gpt-4o-mini', maxHistory: 15 }))
    .withTts(
      new MiniMaxTTS({
        model: 'speech_2_6_turbo',
        voiceId: 'English_captivating_female1',
      }),
    );

  const session = agent.createSession({
    channel,
    agentUid: AGENT_UID,
    remoteUids: ['*'],
    name: 'support-agent',
    idleTimeout: 30,
    expiresIn: ExpiresIn.hours(1),
  });

  try {
    const { agentId } = await session.start();
    return NextResponse.json({ agentId, agentUid: AGENT_UID });
  } catch (err: unknown) {
    const message = err instanceof Error ? err.message : String(err);
    return NextResponse.json({ error: `start failed: ${message}` }, { status: 502 });
  }
}

// app/api/stop-conversation/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { AgoraClient, Area } from 'agora-agents';

const client = new AgoraClient({
  area: Area.US,
  appId: process.env.NEXT_PUBLIC_AGORA_APP_ID!,
  appCertificate: process.env.NEXT_AGORA_APP_CERTIFICATE!,
});

export async function POST(req: NextRequest) {
  const { agentId } = await req.json();
  if (!agentId) {
    return NextResponse.json({ error: 'agentId required' }, { status: 400 });
  }

  try {
    await client.agents.leave(agentId);
    return NextResponse.json({ stopped: true });
  } catch (err: unknown) {
    const message = err instanceof Error ? err.message : String(err);
    return NextResponse.json({ error: `stop failed: ${message}` }, { status: 502 });
  }
}

# server-python/main.py
import os
import time
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from dotenv import load_dotenv
from agora_token_builder import RtcTokenBuilder, RtmTokenBuilder

load_dotenv()

APP_ID = os.environ["APP_ID"]
APP_CERTIFICATE = os.environ["APP_CERTIFICATE"]
TOKEN_TTL_SECONDS = 60 * 60

app = FastAPI()
app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:3000"],
    allow_methods=["POST"],
    allow_headers=["*"],
)

class TokenRequest(BaseModel):
    channel: str
    uid: int

@app.post("/api/token")
def token(body: TokenRequest):
    expire_at = int(time.time()) + TOKEN_TTL_SECONDS
    rtc_token = RtcTokenBuilder.buildTokenWithUid(
        APP_ID,
        APP_CERTIFICATE,
        body.channel,
        body.uid,
        role=1,
        privilegeExpiredTs=expire_at,
    )
    rtm_token = RtmTokenBuilder.buildToken(
        APP_ID,
        APP_CERTIFICATE,
        str(body.uid),
        role=1,
        privilegeExpiredTs=expire_at,
    )
    return {"rtcToken": rtc_token, "rtmToken": rtm_token, "expireAt": expire_at}

from agora_agent import (
    Agora,
    Agent,
    Area,
    DeepgramSTT,
    MiniMaxTTS,
    OpenAI,
    expires_in_hours,
)

agora_client = Agora(
    area=Area.US,
    app_id=APP_ID,
    app_certificate=APP_CERTIFICATE,
)
AGENT_UID = 123456

class InviteRequest(BaseModel):
    channel: str

@app.post("/api/invite-agent")
def invite_agent(body: InviteRequest):
    agent = (
        Agent(
            agora_client,
            instructions="You are a friendly support agent for Acme Corp. Keep answers under 30 seconds.",
            greeting="Hi there! How can I help you today?",
            failure_message="Sorry, I had trouble hearing that. Could you repeat?",
            max_history=50,
            advanced_features={"enable_rtm": True, "enable_tools": False},
            parameters={"data_channel": "rtm", "enable_error_message": True},
        )
        .with_stt(DeepgramSTT(model="nova-3", language="en"))
        .with_llm(OpenAI(model="gpt-4o-mini", max_history=15))
        .with_tts(
            MiniMaxTTS(
                model="speech_2_6_turbo",
                voice_id="English_captivating_female1",
            )
        )
    )

    session = agent.create_session(
        channel=body.channel,
        agent_uid=AGENT_UID,
        remote_uids=["*"],
        name="support-agent",
        idle_timeout=30,
        expires_in=expires_in_hours(1),
    )

    try:
        result = session.start()
        return {"agentId": result.agent_id, "agentUid": AGENT_UID}
    except Exception as exc:
        raise HTTPException(status_code=502, detail=f"start failed: {exc}")

class StopRequest(BaseModel):
    agentId: str

@app.post("/api/stop-conversation")
def stop_conversation(body: StopRequest):
    try:
        agora_client.agents.leave(body.agentId)
        return {"stopped": True}
    except Exception as exc:
        raise HTTPException(status_code=502, detail=f"stop failed: {exc}")

cd server-python
uvicorn main:app --reload --port 8000

pnpm dev

# Terminal 1: Backend
cd server-python
source .venv/bin/activate
uvicorn main:app --reload --port 8000

# Terminal 2: Frontend
cd web-client
pnpm dev