Meeting bot

Meeting call (Zoom / Meet)
    ↓ audio feed via meeting SDK or virtual audio device
Python / Node service
    ↓ cosmo-ai-sdk session
Cosmo agent
    ↓ transcript / model-text events
Transcript buffer + summary (your app)
    ↓ at meeting end
Follow-up note (your storage)

"""
meeting_bot.py — minimal skeleton for a Cosmo meeting transcription bot.

Prerequisites:
  pip install cosmo-ai-sdk

Audio piping: your meeting SDK captures the call audio and feeds it into an
rtc.AudioSource. The exact method depends on the meeting platform.
"""

from __future__ import annotations

import asyncio
import os

import structlog
from livekit import rtc

from cosmo_ai import (
    CosmoRealtime,
    RealtimeModelText,
    RealtimeReady,
    RealtimeSessionEnded,
    RealtimeTranscriptDelta,
)

logger = structlog.get_logger(__name__)

NOTETAKER_INSTRUCTIONS = """You are a silent meeting notetaker. Do not speak
unless addressed directly. When asked for a summary, write a structured note
with key decisions and action items."""

TRANSCRIPT_BUFFER: list[dict[str, str]] = []
SUMMARY_PARTS: list[str] = []


async def run_meeting_bot(api_key: str) -> None:
    async with CosmoRealtime(api_key=api_key) as client:
        agent = client.agent(instructions=NOTETAKER_INSTRUCTIONS)
        async with agent.start(store_recording=True) as session:
            logger.info("bot.connected", room=session.response.room_name)

            # Publish the meeting audio as the bot's voice input. livekit-rtc
            # has no OS capture — your meeting integration keeps this source
            # fed via source.capture_frame(...).
            source = rtc.AudioSource(sample_rate=48000, num_channels=1)
            await session.publish_audio_source(source)

            async def consume_events() -> None:
                async for event in session:
                    if isinstance(event, RealtimeReady):
                        logger.info("bot.ready", session_id=event.session_id)
                    elif isinstance(event, RealtimeTranscriptDelta):
                        if event.is_final:
                            entry = {"role": event.role.value, "text": event.text}
                            TRANSCRIPT_BUFFER.append(entry)
                            logger.info("transcript", **entry)
                    elif isinstance(event, RealtimeModelText):
                        if event.is_final:
                            SUMMARY_PARTS.append(event.text)
                    elif isinstance(event, RealtimeSessionEnded):
                        logger.info("bot.session_ended", reason=event.reason)

            consumer = asyncio.create_task(consume_events())

            # Wait for the meeting to end. In production, this would be
            # signaled by your meeting platform webhook or a shutdown event.
            meeting_ended = asyncio.Event()
            await meeting_ended.wait()

            # Ask the agent for the summary over the text channel.
            await session.send_text(
                "The meeting has ended. Write a structured summary with "
                "key decisions and action items.",
            )

            # Give the agent time to finish writing.
            await asyncio.sleep(10)
            await session.end()
            await consumer

    persist_follow_up_note(TRANSCRIPT_BUFFER, "".join(SUMMARY_PARTS))


if __name__ == "__main__":
    asyncio.run(run_meeting_bot(api_key=os.environ["COSMO_API_KEY"]))

import { RealtimeClient } from 'cosmo-ai';

const NOTETAKER_INSTRUCTIONS = `You are a silent meeting notetaker. …`;

const transcript: Array<{ role: string; text: string }> = [];
const summaryParts: string[] = [];

const client = new RealtimeClient({
  baseUrl: 'https://app.askcosmo.ai',
  apiKey: process.env.COSMO_API_KEY,
});

const agent = client.agent({ instructions: NOTETAKER_INSTRUCTIONS });
const session = await agent.start({ storeRecording: true });

session.on('ready', (event) => {
  console.log('session ready', event.sessionId);
});

session.on('transcript', (event) => {
  if (event.isFinal) {
    transcript.push({ role: event.role, text: event.text });
    console.log(`[${event.role}]`, event.text);
  }
});

session.on('model_text', (event) => {
  if (event.isFinal) summaryParts.push(event.text);
});

// …meeting runs; audio is piped in via your platform integration…

// When the meeting ends:
await session.sendText(
  'The meeting has ended. Write a structured summary with key decisions and action items.',
);
// Allow time for the summary to finish streaming.
await new Promise((resolve) => setTimeout(resolve, 10_000));
await session.end();

persistFollowUpNote(transcript, summaryParts.join(''));

async with agent.start(resume_session_id=prior_session_id) as session:
    ...

const session = await agent.start({ resumeSessionId: priorSessionId });

from cosmo_ai import WebSearchTool

agent = client.agent(
    instructions=NOTETAKER_INSTRUCTIONS,
    tools=[WebSearchTool()],
)