Customer support is the single highest-ROI use case for large language models in 2026. Tickets are repetitive, knowledge is documented, and the cost of getting it wrong is bounded by an escalation to a human. Claude Sonnet 4.5 — accessed through Claudexia at https://api.claudexia.tech/v1 — gives you the reasoning quality of a frontier model with prompt caching and tool use baked in, so a small team can ship a production chatbot in roughly a week. This guide walks through requirements, architecture, prompts, tools, evals, escalation, guardrails, and cost.
Requirements: what a real support bot must do
Before writing a single line of code, pin down four non-negotiables. First, knowledge-base grounding: the bot must answer from your docs and ticket history, not from the model's training data. Hallucinations on pricing, refund policy, or API limits will burn customer trust faster than a slow response ever could. Second, brand tone: the bot is your brand's voice at 3am. It needs a tone spec — warm-but-precise, never sycophantic, never robotic — and that spec lives in the system prompt. Third, escalation to a human: every bot will hit questions it cannot or should not answer. The handoff must be clean, with full conversation context handed to the agent. Fourth, multilingual: if you sell internationally, day-one support for at least English, Russian, Spanish, and German is table stakes — and Claude handles all four natively without translation layers.
A fifth requirement is often forgotten: measurability. You need an eval set from day one. Without it, every prompt change is a guess.
Architecture: four moving parts
The reference architecture is deliberately boring:
[Web/Mobile UI] → [Your Backend] → [Claudexia API] → [Claude Sonnet 4.5]
↓
[Vector DB + CRM]
The frontend is a chat widget — React, Vue, or a native mobile component. It streams tokens for perceived responsiveness. The backend is a thin orchestration layer: it authenticates the user, retrieves relevant KB chunks, calls Claudexia, executes tool calls (CRM lookups, ticket creation), and streams the response back. Claudexia at https://api.claudexia.tech/v1 is a drop-in replacement for the Anthropic API — same request shape, same SDKs — so you can reuse the official @anthropic-ai/sdk or anthropic Python package.
Retrieval-augmented generation (RAG) sits between your docs and the prompt. Index two corpora: (1) your public help center and product docs, chunked at ~500 tokens with overlap; (2) anonymized resolved tickets from the last 12 months — these are gold, because they capture how questions are actually asked, not how docs are written. Embed both into a vector store (pgvector, Qdrant, or Pinecone), retrieve top-k=5 chunks per query, and inject them into the system prompt under a <knowledge> block.
The system prompt template
The system prompt is your most leveraged asset. Treat it like production code: version it, review it, eval it. A solid template has five sections:
You are Aria, the AI support agent for Acme Corp.
# Role
Help paying customers with billing, account, and product questions.
You are NOT a salesperson. You are NOT a lawyer. You are NOT a doctor.
# Tone
- Warm, precise, concise. Never apologize more than once per turn.
- No filler ("Great question!", "Absolutely!"). Get to the answer.
- Use the customer's name once, in the first reply only.
- Match the customer's language (en, ru, es, de, fr).
# Tools
You have access to:
- lookup_ticket(ticket_id): fetch ticket details
- lookup_customer(email): fetch plan, status, MRR
- create_ticket(subject, body, priority): file a new ticket
- escalate_to_human(reason): hand off to a live agent
# Escalation rules
Escalate immediately if:
- Customer is angry, threatening churn, or mentions legal/press
- Question involves refunds > $500 or contract changes
- You are \<80% confident in the answer
- Customer explicitly asks for a human
# Knowledge
<knowledge>
{{retrieved_chunks}}
</knowledge>
Always cite the doc section you used. If knowledge is missing, say so
and escalate. Never invent policy, pricing, or limits.
Pin everything above the <knowledge> block as the cacheable prefix. With Claudexia's prompt caching, this 800-token system prompt costs ~10% of the input rate after the first hit — at 10,000 tickets/month, that's the difference between a $60 bill and a $400 bill.
Tool use: where the bot becomes useful
A bot that only answers from docs is a search engine with manners. The leap to "useful" comes from tool use. Define tools in the request:
const response = await client.messages.create({
model: "claude-sonnet-4.5",
max_tokens: 1024,
system: [
{ type: "text", text: SYSTEM_PROMPT, cache_control: { type: "ephemeral" } },
{ type: "text", text: `<knowledge>${chunks}</knowledge>` }
],
tools: [
{
name: "lookup_ticket",
description: "Fetch ticket details by ID",
input_schema: {
type: "object",
properties: { ticket_id: { type: "string" } },
required: ["ticket_id"]
}
},
// ... other tools
],
messages: conversation
}, {
baseURL: "https://api.claudexia.tech/v1"
});
When Claude returns a tool_use block, your backend executes the call against the CRM, returns the result as a tool_result, and Claude continues the turn. This loop is what lets the bot say "I see your invoice from March 14 was $89 — your card was declined; want me to retry it?" instead of "Please contact billing."
Streaming for perceived responsiveness
Time-to-first-token matters more than total latency. Stream every response:
const stream = await client.messages.stream({
model: "claude-sonnet-4.5",
max_tokens: 1024,
messages,
system,
tools
}, { baseURL: "https://api.claudexia.tech/v1" });
for await (const event of stream) {
if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
socket.send(event.delta.text);
}
}
A user who sees text appear in 400ms perceives the bot as fast even if the full reply takes 6 seconds. A user who waits 6 seconds for a complete reply churns out of the chat.
Evals: the thing that separates toys from products
Build an eval set of 200–500 real tickets, labeled with the ideal response, the correct tool calls, and whether escalation was warranted. Score each new prompt version on three axes: factual accuracy (does it match docs?), tone fidelity (does it sound like the brand?), and escalation precision (does it hand off when it should, and only when it should?). Use Claude itself as a judge for the first two — a meta-prompt with the rubric and the candidate response — and use exact-match against ticket-history outcomes for the third.
Run evals on every prompt change. Run them on every model upgrade. Without this, you have no way to know whether your "improvement" actually improved anything. See our pricing breakdown for cost modeling on eval runs.
Escalation pattern: draft, score, route
The cleanest escalation pattern is draft-then-route. The model always produces a candidate reply. A second, smaller call (or a confidence rubric inside the same call) scores it 0–1. If confidence ≥ 0.85, send the reply. If 0.6–0.85, send the reply with a "Was this helpful? A human is standing by" footer. If < 0.6, drop the reply, hand the conversation to the queue, and pre-fill the agent's reply box with the draft — the human edits and sends. Agents love this; it cuts their average handle time by 40–60% even on escalated tickets.
Guardrails: PII, scope, and refusals
Three guardrails belong in every support bot. PII echo prevention: scrub credit card numbers, full SSNs, and passwords from both inputs and outputs with a regex pass before they touch the model. Out-of-scope refusals: the system prompt explicitly lists what the bot does NOT do (legal advice, medical questions, competitor comparisons), and you reinforce this with a few-shot example. Prompt injection resistance: never put untrusted user content (ticket bodies, email forwards) into the system prompt; always put it in a user message wrapped in <untrusted> tags, and instruct the model to treat instructions inside those tags as data, not commands.
Multilingual: free, native, no translation layer
Claude Sonnet 4.5 is genuinely multilingual. Detect the customer's language from their first message (a one-line classifier prompt or a library like franc), set it as a directive in the system prompt (Respond in: ru), and you're done. No Google Translate hop, no quality degradation, no separate prompts per language. The same eval set, translated by Claude itself and spot-checked by native speakers, validates each language.
Cost projection: a typical SMB
For a B2B SaaS handling 10,000 tickets per month, with average conversation length of 6 turns and ~3,000 input tokens (system + KB + history) plus ~400 output tokens per turn:
- Without prompt caching: ~180M input tokens + ~24M output tokens ≈ $720/month
- With prompt caching (system + KB cached, ~85% hit rate): ~$60/month
- Plus embeddings + vector DB: ~$20/month
So roughly $80/month all-in for a fully multilingual, tool-using, escalation-aware bot serving 10k tickets. That is one-third of a single seat at most legacy support-automation vendors.
Claudexia setup
Point your SDK at https://api.claudexia.tech/v1, use your Claudexia API key, and the rest of the code is identical to the official Anthropic SDK. Prompt caching, tool use, streaming, and vision all work the same way. Billing is in rubles or USD, settlement is in 1-minute increments, and there is no per-seat fee — you pay for the tokens you use.
Bottom line
You can ship an MVP in a week: day 1–2 ingest docs and tickets into a vector store; day 3 wire up the chat UI with streaming; day 4 write the system prompt and tool schemas; day 5 build the escalation queue; day 6 assemble the eval set; day 7 ship to 10% of traffic behind a feature flag. From there, every week is a prompt iteration informed by evals and real conversations. The bot that ships in week one will be embarrassing in week four — that is the point. Build the loop, not the perfect prompt.