Add TAC to your agent

1
TWILIO_ACCOUNT_SID=your_account_sid
2
TWILIO_AUTH_TOKEN=your_auth_token
3
TWILIO_API_KEY=your_api_key_sid
4
TWILIO_API_SECRET=your_api_key_secret
5
TWILIO_PHONE_NUMBER=+1234567890
6
TWILIO_CONVERSATION_CONFIGURATION_ID=your_configuration_id
7
TWILIO_VOICE_PUBLIC_DOMAIN=your-ngrok-domain.ngrok-free.app

1
TWILIO_ACCOUNT_SID=your_account_sid
2
TWILIO_AUTH_TOKEN=your_auth_token
3
TWILIO_API_KEY=your_api_key_sid
4
TWILIO_API_SECRET=your_api_key_secret
5
TWILIO_PHONE_NUMBER=+1234567890
6
TWILIO_CONVERSATION_CONFIGURATION_ID=your_configuration_id
7
TWILIO_VOICE_PUBLIC_DOMAIN=your-ngrok-domain.ngrok-free.app

1
from dotenv import load_dotenv
2
from tac import TAC, TACConfig
3

4
load_dotenv()
5
tac = TAC(config=TACConfig.from_env())

1
import 'dotenv/config';
2
import { TAC, TACConfig } from 'twilio-agent-connect';
3

4
const tac = await TAC.create({ config: TACConfig.fromEnv() });

1
from tac.channels.voice import VoiceChannel, VoiceChannelConfig
2
from tac.channels.sms import SMSChannel, SMSChannelConfig
3
from tac.channels.whatsapp import WhatsAppChannel, WhatsAppChannelConfig
4
from tac.channels.rcs import RCSChannel, RCSChannelConfig
5

6
voice_channel = VoiceChannel(tac, config=VoiceChannelConfig(memory_mode="always"))
7
sms_channel = SMSChannel(tac, config=SMSChannelConfig(memory_mode="always"))
8
whatsapp_channel = WhatsAppChannel(tac, config=WhatsAppChannelConfig(memory_mode="always"))
9
rcs_channel = RCSChannel(tac, config=RCSChannelConfig(memory_mode="always"))

1
import { VoiceChannel, SMSChannel, WhatsAppChannel, RCSChannel } from 'twilio-agent-connect';
2

3
const voiceChannel = new VoiceChannel(tac, { memoryMode: 'always' });
4
const smsChannel = new SMSChannel(tac, { memoryMode: 'always' });
5
const whatsAppChannel = new WhatsAppChannel(tac, { memoryMode: 'always' });
6
const rcsChannel = new RCSChannel(tac, { memoryMode: 'always' });
7

8
tac.registerChannel(voiceChannel);
9
tac.registerChannel(smsChannel);
10
tac.registerChannel(whatsAppChannel);
11
tac.registerChannel(rcsChannel);

1
from tac.models.session import ConversationSession
2
from tac.models.tac import TACMemoryResponse
3

4
conversation_history: dict[str, list] = {}
5

6
async def handle_message_ready(
7
    message: str,
8
    context: ConversationSession,
9
    memory: TACMemoryResponse | None,
10
) -> str | None:
11
    conv_id = context.conversation_id
12

13
    if conv_id not in conversation_history:
14
        conversation_history[conv_id] = []
15

16
    conversation_history[conv_id].append({"role": "user", "content": message})
17

18
    # Process with your LLM (see following sections)
19
    llm_response = await generate_response(conversation_history[conv_id])
20

21
    conversation_history[conv_id].append({"role": "assistant", "content": llm_response})
22

23
    return llm_response
24

25
tac.on_message_ready(handle_message_ready)

1
const conversationHistory: Record<string, Array<{ role: string; content: string }>> = {};
2

3
tac.onMessageReady(async ({ conversationId, message, memory, session, channel }) => {
4
  const convId = conversationId as string;
5

6
  if (!conversationHistory[convId]) {
7
    conversationHistory[convId] = [];
8
  }
9

10
  conversationHistory[convId].push({ role: 'user', content: message });
11

12
  // Process with your LLM (see following sections)
13
  const llmResponse = await generateResponse(conversationHistory[convId]);
14

15
  conversationHistory[convId].push({ role: 'assistant', content: llmResponse });
16

17
  return llmResponse;
18
});

1
from tac.adapters.prompt_builder import MemoryPromptBuilder
2

3
SYSTEM_PROMPT = "You are a helpful customer service agent. Be concise and friendly."
4

5
async def handle_message_ready(
6
    message: str,
7
    context: ConversationSession,
8
    memory: TACMemoryResponse | None,
9
) -> str | None:
10
    conv_id = context.conversation_id
11

12
    if conv_id not in conversation_history:
13
        conversation_history[conv_id] = []
14

15
    conversation_history[conv_id].append({"role": "user", "content": message})
16

17
    # Build memory context from profile traits and conversation history
18
    memory_context = MemoryPromptBuilder.build(
19
        memory_response=memory,
20
        context=context,
21
    )
22

23
    # Combine your prompt with memory context
24
    if memory_context:
25
        system_prompt = f"{SYSTEM_PROMPT}\n\n{memory_context}"
26
    else:
27
        system_prompt = SYSTEM_PROMPT
28

29
    # Pass to your LLM as the system message
30
    messages = [
31
        {"role": "system", "content": system_prompt},
32
        *conversation_history[conv_id],
33
    ]
34

35
    response = await openai_client.chat.completions.create(
36
        model="gpt-4o-mini",
37
        messages=messages,
38
    )
39

40
    llm_response = response.choices[0].message.content
41
    conversation_history[conv_id].append({"role": "assistant", "content": llm_response})
42

43
    return llm_response

1
import { MemoryPromptBuilder } from 'twilio-agent-connect';
2

3
const SYSTEM_PROMPT = 'You are a helpful customer service agent. Be concise and friendly.';
4

5
tac.onMessageReady(async ({ conversationId, message, memory, session }) => {
6
  const convId = conversationId as string;
7

8
  if (!conversationHistory[convId]) {
9
    conversationHistory[convId] = [];
10
  }
11

12
  conversationHistory[convId].push({ role: 'user', content: message });
13

14
  // Build memory context from profile traits and conversation history
15
  const memoryContext = MemoryPromptBuilder.build(memory, session);
16
  const systemContent = memoryContext
17
    ? `${SYSTEM_PROMPT}\n\n${memoryContext}`
18
    : SYSTEM_PROMPT;
19

20
  const response = await openai.chat.completions.create({
21
    model: 'gpt-4o-mini',
22
    messages: [
23
      { role: 'system', content: systemContent },
24
      ...conversationHistory[convId],
25
    ],
26
  });
27

28
  const llmResponse = response.choices[0]?.message?.content ?? '';
29
  conversationHistory[convId].push({ role: 'assistant', content: llmResponse });
30

31
  return llmResponse;
32
});

1
from openai import AsyncOpenAI
2
from tac.adapters.openai import with_tac_memory
3

4
openai_client = AsyncOpenAI()
5

6
async def handle_message_ready(
7
    message: str,
8
    context: ConversationSession,
9
    memory: TACMemoryResponse | None,
10
) -> str | None:
11
    # Wrap the OpenAI client — memory context is added to your messages before each LLM call
12
    client = with_tac_memory(openai_client, memory, context)
13

14
    response = await client.chat.completions.create(
15
        model="gpt-4o-mini",
16
        messages=conversation_history[context.conversation_id],
17
    )
18

19
    llm_response = response.choices[0].message.content
20

21
    return llm_response

1
import OpenAI from 'openai';
2
import { MemoryPromptBuilder } from 'twilio-agent-connect';
3

4
const openai = new OpenAI();
5

6
tac.onMessageReady(async ({ conversationId, message, memory, session }) => {
7
  const convId = conversationId as string;
8
  const memoryContext = MemoryPromptBuilder.build(memory, session);
9

10
  const response = await openai.chat.completions.create({
11
    model: 'gpt-4o-mini',
12
    messages: [
13
      { role: 'system', content: memoryContext
14
        ? `${SYSTEM_PROMPT}\n\n${memoryContext}`
15
        : SYSTEM_PROMPT },
16
      ...conversationHistory[convId],
17
    ],
18
  });
19

20
  const llmResponse = response.choices[0]?.message?.content ?? '';
21

22
  return llmResponse;
23
});

1
from tac.tools import create_knowledge_tool
2

3
knowledge_tool = await create_knowledge_tool(
4
    knowledge_client=tac.knowledge_client,
5
    knowledge_base_id="know_knowledgebase_xxxxx",
6
)
7

8
# Add to your LLM's tool list alongside custom tools
9
tools = [check_order_status, knowledge_tool]

1
import { createKnowledgeSearchToolAsync } from 'twilio-agent-connect';
2

3
const knowledgeClient = tac.getKnowledgeClient();
4
const knowledgeTool = await createKnowledgeSearchToolAsync(
5
  knowledgeClient,
6
  'know_knowledgebase_xxxxx'
7
);
8

9
// Add to your LLM's tool list alongside custom tools
10
const tools = [checkOrderStatus, knowledgeTool];

1
from collections.abc import AsyncGenerator
2

3
async def handle_message_ready(
4
    message: str,
5
    context: ConversationSession,
6
    memory: TACMemoryResponse | None,
7
) -> str | None:
8
    conv_id = context.conversation_id
9

10
    if conv_id not in conversation_history:
11
        conversation_history[conv_id] = []
12

13
    conversation_history[conv_id].append({"role": "user", "content": message})
14

15
    async def stream_tokens() -> AsyncGenerator[str, None]:
16
        response_tokens = []
17

18
        stream = await openai_client.chat.completions.create(
19
            model="gpt-4o-mini",
20
            messages=conversation_history[conv_id],
21
            stream=True,
22
        )
23

24
        async for chunk in stream:
25
            if chunk.choices and chunk.choices[0].delta.content:
26
                token = chunk.choices[0].delta.content
27
                response_tokens.append(token)
28
                yield token
29

30
        full_response = "".join(response_tokens)
31
        conversation_history[conv_id].append({"role": "assistant", "content": full_response})
32

33
    if context.channel == "voice":
34
        await voice_channel.send_response(conv_id, stream_tokens())
35
    elif context.channel == "sms":
36
        llm_response = await generate_response(conversation_history[conv_id])
37
        conversation_history[conv_id].append({"role": "assistant", "content": llm_response})
38
        await sms_channel.send_response(conv_id, llm_response)
39

40
tac.on_message_ready(handle_message_ready)

1
import OpenAI from 'openai';
2

3
const openai = new OpenAI();
4

5
tac.onMessageReady(async ({ conversationId, message, channel, abortSignal }) => {
6
  const convId = conversationId as string;
7

8
  if (!conversationHistory[convId]) {
9
    conversationHistory[convId] = [];
10
  }
11

12
  conversationHistory[convId].push({ role: 'user', content: message });
13

14
  if (channel === 'voice') {
15
    if (abortSignal?.aborted) return;
16

17
    const stream = await openai.chat.completions.create({
18
      model: 'gpt-4o-mini',
19
      messages: conversationHistory[convId],
20
      stream: true,
21
    });
22

23
    async function* tokenStream() {
24
      for await (const chunk of stream) {
25
        if (chunk.choices?.[0]?.delta?.content) {
26
          yield chunk.choices[0].delta.content;
27
        }
28
      }
29
    }
30

31
    const fullResponse = await voiceChannel.sendStreamingResponse(
32
      conversationId,
33
      tokenStream(),
34
      abortSignal !== undefined ? { signal: abortSignal } : undefined
35
    );
36

37
    conversationHistory[convId].push({ role: 'assistant', content: fullResponse });
38
  } else if (channel === 'sms') {
39
    const response = await openai.chat.completions.create({
40
      model: 'gpt-4o-mini',
41
      messages: conversationHistory[convId],
42
    });
43

44
    const llmResponse = response.choices[0]?.message?.content ?? '';
45
    conversationHistory[convId].push({ role: 'assistant', content: llmResponse });
46
    await smsChannel.sendResponse(conversationId, llmResponse);
47
  }
48
});

1
from tac.server import TACFastAPIServer
2

3
if __name__ == "__main__":
4
    server = TACFastAPIServer(
5
        tac=tac,
6
        voice_channel=voice_channel,
7
        messaging_channels=[sms_channel],
8
    )
9
    server.start()

1
import { TACServer } from 'twilio-agent-connect';
2

3
const server = new TACServer(tac, {
4
  host: '0.0.0.0',
5
  port: 8000,
6
});
7

8
server.start().then(() => {
9
  console.log('TAC server started');
10
});