Building a chatbot used to mean wrangling intent classifiers, dialogue trees, and a mountain of edge cases. With a modern language model API, the model handles the hard part \u2014 understanding and responding \u2014 and your job is the wiring around it. With the Claude API you can have a genuinely capable chatbot working in well under an hour.<\/p>\n
This guide walks through the concepts and the code: setup, holding a conversation, steering behavior, streaming responses, and keeping costs down.<\/p>\n
You need two things: an API key and the SDK.<\/p>\n
pip install anthropic\n<\/code><\/pre>\n(A Node.js SDK is available too; the concepts below are identical.)<\/p>\n
Step 2: Your first message<\/h2>\n
The heart of the Claude API is the Messages API<\/strong>. You send a list of messages; Claude returns the next one. Here’s the simplest possible call:<\/p>\nfrom anthropic import Anthropic\n\nclient = Anthropic() # reads the ANTHROPIC_API_KEY environment variable\n\nresponse = client.messages.create(\n model="claude-sonnet-4-6",\n max_tokens=1024,\n messages=[\n {"role": "user", "content": "Hello! What can you help me with?"}\n ],\n)\n\nprint(response.content[0].text)\n<\/code><\/pre>\nThat’s a working \u2014 if very forgetful \u2014 chatbot. model<\/code> selects which Claude to use, max_tokens<\/code> caps the reply length, and messages<\/code> is the conversation so far.<\/p>\nStep 3: Give it a memory<\/h2>\n
The example above has no memory: each call is independent. To hold a real conversation, you<\/strong> keep the history and resend it every turn. The API itself is stateless \u2014 it knows only what you send it.<\/p>\nThe pattern: maintain a messages<\/code> list, append each user message and each Claude reply, and pass the whole list on every call.<\/p>\nfrom anthropic import Anthropic\n\nclient = Anthropic()\nmessages = []\n\nwhile True:\n user_input = input("You: ")\n if user_input.lower() == "quit":\n break\n\n messages.append({"role": "user", "content": user_input})\n\n response = client.messages.create(\n model="claude-sonnet-4-6",\n max_tokens=1024,\n messages=messages,\n )\n\n reply = response.content[0].text\n print(f"Claude: {reply}")\n\n messages.append({"role": "assistant", "content": reply})\n<\/code><\/pre>\nNow it’s a real chatbot \u2014 it remembers everything earlier in the conversation, because that history is sent every turn.<\/p>\n
Step 4: Set its personality with a system prompt<\/h2>\n
A generic assistant is rarely what you want. The system prompt<\/strong> defines the bot’s role, tone, and rules. It’s passed as a separate system<\/code> parameter, not as a message.<\/p>\nSYSTEM_PROMPT = """You are a friendly support assistant for a coffee\nsubscription service. Be warm, concise, and helpful. If a customer asks\nabout something you don't know, tell them you'll connect them to a human\nagent. Never discuss competitors."""\n\nresponse = client.messages.create(\n model="claude-sonnet-4-6",\n max_tokens=1024,\n system=SYSTEM_PROMPT,\n messages=messages,\n)\n<\/code><\/pre>\nThe system prompt is your main tool for shaping behavior \u2014 invest time in it. Be specific about the role, the tone, what the bot should do when unsure, and any hard boundaries.<\/p>\n
Step 5: Stream the response<\/h2>\n
In the examples above, you wait for the entire reply before anything appears. Real chat interfaces stream \u2014 the text arrives word by word. The SDK makes this straightforward:<\/p>\n
with client.messages.stream(\n model="claude-sonnet-4-6",\n max_tokens=1024,\n system=SYSTEM_PROMPT,\n messages=messages,\n) as stream:\n for text in stream.text_stream:\n print(text, end="", flush=True)\n<\/code><\/pre>\nStreaming doesn’t make generation faster, but it makes the bot feel<\/em> dramatically more responsive, because the user sees output immediately.<\/p>\nStep 6: Keep costs down with prompt caching<\/h2>\n
API calls are billed by tokens, and a chatbot resends a lot of the same text every turn \u2014 the system prompt, and a conversation history that only grows. Prompt caching<\/strong> lets you mark stable parts of the prompt so the API reuses them instead of reprocessing them, which cuts both cost and latency substantially.<\/p>\nYou add a cache marker to the content you want cached \u2014 typically the system prompt, and any long, fixed context:<\/p>\n
response = client.messages.create(\n model="claude-sonnet-4-6",\n max_tokens=1024,\n system=[\n {\n "type": "text",\n "text": SYSTEM_PROMPT,\n "cache_control": {"type": "ephemeral"},\n }\n ],\n messages=messages,\n)\n<\/code><\/pre>\nFor any chatbot that handles real traffic, enable prompt caching from the start \u2014 it’s one of the highest-impact optimizations available, and it costs nothing to turn on.<\/p>\n
Choosing a model<\/h2>\n
Claude comes in a few tiers. As a rule of thumb:<\/p>\n
\n- A fast, balanced model<\/strong> (such as the Sonnet tier) is the right default for most chatbots \u2014 strong quality, good speed, sensible cost.<\/li>\n
- The most capable model<\/strong> (the Opus tier) is worth it when the bot must handle hard reasoning or complex tasks.<\/li>\n
- A smaller, fastest model<\/strong> (the Haiku tier) suits simple, high-volume bots where speed and cost matter most.<\/li>\n<\/ul>\n
Start with the balanced tier and only move up or down once you see real usage.<\/p>\n
Going to production<\/h2>\n
The code above is the working core. For a real deployment, add:<\/p>\n
\n- A web layer<\/strong> \u2014 wrap the logic in an API endpoint and connect a chat UI.<\/li>\n
- History limits<\/strong> \u2014 conversations grow forever; cap or summarize old turns so prompts don’t balloon.<\/li>\n
- Error handling<\/strong> \u2014 handle rate limits and transient failures with retries.<\/li>\n
- Knowledge<\/strong> \u2014 to answer from your own data, add retrieval-augmented generation<\/a> so the bot pulls in relevant documents.<\/li>\n
- Safety<\/strong> \u2014 validate inputs and set clear boundaries in the system prompt.<\/li>\n<\/ul>\n
FAQ<\/h2>\nHow do I build a chatbot with the Claude API?<\/h3>\n
Install Anthropic’s SDK, get an API key, and call the Messages API: send a list of messages and Claude returns a reply. To make it conversational, keep the message history yourself and resend it each turn. Add a system prompt for personality and streaming for a responsive feel.<\/p>\n
Does the Claude API remember previous messages?<\/h3>\n
No \u2014 the API is stateless. It only knows what you send in a given request. To give a chatbot memory, your application must store the conversation history and include it in the messages<\/code> list on every call.<\/p>\nWhat is a system prompt?<\/h3>\n
The system prompt is a separate instruction that defines the chatbot’s role, tone, and rules \u2014 for example, “You are a concise support assistant; escalate to a human when unsure.” It’s passed as the system<\/code> parameter and is the main way to shape how the bot behaves.<\/p>\nHow much does it cost to run a Claude chatbot?<\/h3>\n
Cost depends on the model and how many tokens you process. A balanced model is inexpensive for typical chat traffic. Because chatbots resend the system prompt and growing history each turn, enabling prompt caching can cut costs significantly \u2014 it reuses stable parts of the prompt instead of reprocessing them.<\/p>\n
Which Claude model should I use for a chatbot?<\/h3>\n
For most chatbots, start with a fast, balanced model (the Sonnet tier) \u2014 it offers strong quality at sensible speed and cost. Use the most capable model for complex reasoning tasks, and a smaller, faster model for simple high-volume bots.<\/p>\n
Bottom line<\/h2>\n