Building a simple Nepali chatbot

What we’re building

chiya is:

• Nepali-first: it responds in the same language the user writes in (Nepali if Nepali, English if English), and knows a little bit of Nepal-specific context.
• Narrow: it’s a daily-life assistant, not a doctor or lawyer or financial advisor. If the user asks something outside its scope, it politely says so.
• Careful: it declines to give medical, legal, or financial advice. It does not invent facts.
• Cheap: it uses Claude Haiku and a sliding-window strategy. Bounded per-conversation cost.
• Streaming: responses appear token by token, not all at once — the UX feels alive.

The full code is one file. Below we walk through it piece by piece.

Step 1 — the system prompt

The system prompt defines chiya’s identity:

SYSTEM_PROMPT = """You are chiya (चिया), a friendly Nepali-speaking assistant
for everyday questions.

Your scope:
- Everyday-life questions: cooking, travel, festivals, general knowledge
  about Nepal, language questions, small explanations.
- Respond in the same language the user writes in. If the user writes
  in Devanagari Nepali, respond in Devanagari Nepali. If they write
  in Romanised Nepali, do the same. If they write in English, respond
  in English.

Your limits:
- Never give medical, legal, or financial advice. If asked, politely
  decline and suggest the user speak with a qualified professional.
- Never claim knowledge of events after your training cutoff, or of
  the user's private information beyond what they've shared in this
  chat.
- Never pretend to be a human. If asked if you're an AI, say yes.

Your style:
- Keep responses concise: 2-4 sentences unless the user asks for detail.
- Warm and friendly, but not saccharine. Use "तपाईं" for polite Nepali
  address, not "तिमी" or "तँ".
- Use plain language. If a user seems confused, offer a follow-up
  question to clarify.
"""

Read this. Every line is a rule that has come from real chatbot failures. Scope prevents scope creep. Language rule prevents the “started in Nepali, drifted to English” bug. Limits prevent liability. Style rules prevent the two most common chatbot smells — over-formal and over-cheery.

Step 2 — the Conversation class

Reusing what we built in the previous section, adapted for streaming:

import os
import time
from dataclasses import dataclass, field
from dotenv import load_dotenv
import anthropic

load_dotenv()
_client = anthropic.Anthropic()


HAIKU_INPUT_PER_M  = 0.25
HAIKU_OUTPUT_PER_M = 1.25


@dataclass
class Chiya:
    system_prompt: str = SYSTEM_PROMPT
    window: int = 12
    model: str = "claude-haiku-4-5-20251001"
    messages: list = field(default_factory=list)
    total_input_tokens: int = 0
    total_output_tokens: int = 0

    def _recent_messages(self) -> list:
        # Keep last `window` pairs of user+assistant messages
        return self.messages[-(self.window * 2):]

    def ask_streaming(self, user_message: str) -> str:
        self.messages.append({"role": "user", "content": user_message})

        full_text = ""
        with _client.messages.stream(
            model=self.model,
            max_tokens=800,
            temperature=0.7,
            system=self.system_prompt,
            messages=self._recent_messages(),
        ) as stream:
            for text_chunk in stream.text_stream:
                print(text_chunk, end="", flush=True)
                full_text += text_chunk
            print()

            # After stream completes, get usage
            final_message = stream.get_final_message()
            self.total_input_tokens  += final_message.usage.input_tokens
            self.total_output_tokens += final_message.usage.output_tokens

        self.messages.append({"role": "assistant", "content": full_text})
        return full_text

    def cost_so_far(self) -> float:
        return (
            self.total_input_tokens  / 1_000_000 * HAIKU_INPUT_PER_M +
            self.total_output_tokens / 1_000_000 * HAIKU_OUTPUT_PER_M
        )

Fifty lines. Streams responses, tracks tokens, keeps a sliding window of the last 12 turns.

Step 3 — the CLI

A friendly command-line UI:

def run():
    print("चिया — तपाईंको दैनिक सहायक")
    print("(type 'quit' to exit, 'cost' to see running cost, 'reset' to start over)\n")

    chiya = Chiya()

    while True:
        try:
            user_input = input("You: ").strip()
        except (KeyboardInterrupt, EOFError):
            print()
            break

        if not user_input:
            continue
        if user_input.lower() in {"quit", "exit", "bye"}:
            print(f"Bye! Total cost: ${chiya.cost_so_far():.5f}")
            break
        if user_input.lower() == "cost":
            print(f"[cost so far: ${chiya.cost_so_far():.5f} "
                  f"| tokens: {chiya.total_input_tokens} in / "
                  f"{chiya.total_output_tokens} out]\n")
            continue
        if user_input.lower() == "reset":
            chiya = Chiya()
            print("[Conversation reset.]\n")
            continue

        print("chiya: ", end="", flush=True)
        chiya.ask_streaming(user_input)
        print()


if __name__ == "__main__":
    run()

Twenty-five more lines. Complete assistant.

Full file, put together

# chiya.py
import os
from dataclasses import dataclass, field
from dotenv import load_dotenv
import anthropic

load_dotenv()
_client = anthropic.Anthropic()


SYSTEM_PROMPT = """You are chiya (चिया), a friendly Nepali-speaking assistant
for everyday questions.

Your scope:
- Everyday-life questions: cooking, travel, festivals, general knowledge
  about Nepal, language questions, small explanations.
- Respond in the same language the user writes in.

Your limits:
- Never give medical, legal, or financial advice. Politely decline.
- Never claim knowledge of events after your training cutoff.
- Never pretend to be a human. If asked, say you are an AI.

Your style:
- Keep responses concise: 2-4 sentences unless asked otherwise.
- Warm and friendly, not saccharine.
- Use "तपाईं" for polite Nepali address.
"""


HAIKU_INPUT_PER_M  = 0.25
HAIKU_OUTPUT_PER_M = 1.25


@dataclass
class Chiya:
    system_prompt: str = SYSTEM_PROMPT
    window: int = 12
    model: str = "claude-haiku-4-5-20251001"
    messages: list = field(default_factory=list)
    total_input_tokens: int = 0
    total_output_tokens: int = 0

    def _recent_messages(self) -> list:
        return self.messages[-(self.window * 2):]

    def ask_streaming(self, user_message: str) -> str:
        self.messages.append({"role": "user", "content": user_message})

        full_text = ""
        with _client.messages.stream(
            model=self.model,
            max_tokens=800,
            temperature=0.7,
            system=self.system_prompt,
            messages=self._recent_messages(),
        ) as stream:
            for chunk in stream.text_stream:
                print(chunk, end="", flush=True)
                full_text += chunk
            print()

            final = stream.get_final_message()
            self.total_input_tokens  += final.usage.input_tokens
            self.total_output_tokens += final.usage.output_tokens

        self.messages.append({"role": "assistant", "content": full_text})
        return full_text

    def cost_so_far(self) -> float:
        return (
            self.total_input_tokens  / 1_000_000 * HAIKU_INPUT_PER_M +
            self.total_output_tokens / 1_000_000 * HAIKU_OUTPUT_PER_M
        )


def run():
    print("चिया — तपाईंको दैनिक सहायक")
    print("(type 'quit', 'cost', or 'reset')\n")

    chiya = Chiya()

    while True:
        try:
            user_input = input("You: ").strip()
        except (KeyboardInterrupt, EOFError):
            print()
            break

        if not user_input:
            continue
        if user_input.lower() in {"quit", "exit", "bye"}:
            print(f"Bye! Total cost: ${chiya.cost_so_far():.5f}")
            break
        if user_input.lower() == "cost":
            print(f"[cost: ${chiya.cost_so_far():.5f}]\n")
            continue
        if user_input.lower() == "reset":
            chiya = Chiya()
            print("[Reset.]\n")
            continue

        print("chiya: ", end="", flush=True)
        chiya.ask_streaming(user_input)
        print()


if __name__ == "__main__":
    run()

Under 150 lines. Runs from the terminal. Streams. Tracks cost. Handles the sliding window automatically. This is a complete, honest chatbot.

Trying it

python chiya.py

A sample session:

चिया — तपाईंको दैनिक सहायक
(type 'quit', 'cost', or 'reset')

You: नमस्ते! मलाई नेपाली चियाको सबैभन्दा राम्रो रेसिपी भन्नुहोस्।
chiya: नमस्ते! मेरो साथी। दूध चियाका लागि — पानीमा अदुवा, इलायची, र सुकेको
सक्खर हालेर एक मिनेट उमाल्नुहोस्, अनि चियापत्ती हालेर छिटो उमाल्नुहोस्, र
अन्तमा दूध मिसाएर छान्नुहोस्।

You: मीठो कति हुनुपर्छ?
chiya: तपाईंको स्वादमा भर पर्छ। एक कप चियाका लागि करिब आधा चम्चा चिनी वा
सुकेको सक्खर मिठाइको लागि उपयुक्त हुन्छ। कम मीठो मन पर्ने मानिसका लागि
घटाउनुहोस्।

You: cost
[cost: $0.00087]

You: मलाई डिप्रेसनको औषधि दिनुहोस्।
chiya: मलाई माफ गर्नुहोस्, तर म चिकित्सा सल्लाह दिन सक्दिनँ। कृपया कुनै
मानसिक स्वास्थ्य विशेषज्ञ वा मनोचिकित्सकसँग सल्लाह लिनुहोस्। यदि तपाईंलाई
तत्काल सहयोग चाहिन्छ भने, नेपालको Suicide Prevention Helpline
(1166) सम्पर्क गर्नुहोस्।

You: quit
Bye! Total cost: $0.00201

Note three things:

• It answered the chiya recipe warmly and in Nepali.
• It stayed in scope: friendly on everyday questions.
• It declined the medical question and offered a real Nepali helpline number. This is exactly the behaviour the system prompt was designed to produce.

What’s missing (and what’s next)

chiya is a real, working chatbot. It is also deliberately incomplete:

• No RAG. It can’t answer questions about specific documents you give it. Chapters 4-5 add that.
• No tools. It can’t fetch today’s weather, or your bank balance, or anything real-time. Chapter 6 addresses that.
• No per-user persistence. Sessions don’t remember each other. Adding a user database is straightforward but out of scope here.
• No evaluation. We haven’t measured whether chiya actually helps users. Chapter 6 covers evaluation.

These are the reasons Course 04 has three more chapters.

Check your understanding

Quick check

—

A junior developer wants to extend chiya to also give medical diagnoses because 'the LLM knows medicine.' What's the professional response, in the spirit of this section?

1. AGreat idea — LLMs are trained on medical literature.
2. BStrongly refuse. A general-purpose LLM giving medical advice, even carefully caveated, creates serious harm potential (missed diagnoses, unsafe recommendations, liability). The system prompt is deliberately narrow and should stay that way. Medical AI applications require domain experts, clinical validation, and often regulatory approval — not a chatbot with an expanded system prompt. Narrow, useful, safe beats broad, risky, and impressive for any deployed system.
3. CAdd a disclaimer at the bottom of each medical response.
4. DOnly give medical advice on weekdays.

Check answer→

Quick check

—

A teammate asks whether to use temperature=0.0 for chiya's chat responses (as we do for extraction). What's the right answer?

1. AYes — temperature=0.0 is always right.
2. BNo — for conversational chat, some temperature (0.5-0.8) is right. At 0.0 the same greeting produces literally identical responses every time and the chat feels robotic. Chiya uses 0.7 for chat responses to feel natural. The rule from Chapter 1 stands: temperature=0.0 for extraction/classification/structured output, some warmth (0.5-1.0) for conversational text. Different parts of one app can use different temperatures for different tasks.
3. CUse temperature=2.0 for chatbots.
4. DTemperature doesn't matter for chat.

Check answer→

What comes next

Chapter 3 is done. You have a working chatbot. Chapters 4 and 5 are the biggest architectural leap in this course: embeddings and retrieval-augmented generation — the pattern that lets LLMs answer questions from documents you give them, without hallucinating. This is what turns a general-purpose chatbot like chiya into a specific-purpose assistant like “customer support for our company” or “answer questions about our government’s circulars.” It’s the modern maker’s most-used technique.