How to Build a Streamlit Chatbot in 10 Minutes

1. Give it Instructions

In the studio, we’ll navigate to Home in the left-hand sidebar.

You should see the Instructions section front-and-center. Click on it to add or modify the instructions in plain text.

This gives our bot directives, personality, and guardrails. Using plain-language, you can steer your bot pretty effectively towards the desired behavior. Make it sound more human, and 

2. Build the Flow

This is where the nuts and bolts of the bot’s personality live: access to specific information, rigid steps-by-step, code execution, etc.

Don’t underestimate the power of simplicity. A single autonomous node rivals the functionality of reasoning agents. I have one hooked up to my Knowledge Base (KB).

3. Add the Knowledge Base

If the instructions are about vibes, the KB is about cold, hard facts. In my case, the facts in question are the wines in the Wine Reviews dataset, a list of wines, descriptions, and prices. I’ll be treating this as a de-facto wine inventory for our bot to Sommelier-ize.

I’ll click on Tables in the left panel and hit New Table in the top left of the page, and give it a descriptive name. 

Click on the vertical ellipsis (⋮) on the top-right, and hit Import.

Drag your .csv into the modal that pops up and follow the steps on-screen.

To make the table accessible to your bot, navigate to Knowledge Bases in your left-hand sidebar.

Click the little green table icon and select the relevant source. Click Add tables.

Make sure your flow has access to the Knowledge Base and you’re good to go.

1. Add your credentials

class BotpressClient:
   def __init__(self, api_id=None, user_key=None):
       self.api_id = api_id or os.getenv("CHAT_API_ID")
       self.user_key = user_key or os.getenv("USER_KEY")
       self.base_url = f"{BASE_URI}/{self.api_id}"
       self.headers = {
           **HEADERS,
           "x-user-key": self.user_key,
       }

You’re free to add your Chat API ID to a .env file– it helps with debugging, but it’s not strictly necessary. We’ll deal with the API ID and user key when we build the Streamlit app.

I keep BASE_URI and HEADERS in a separate constants.py file, for clutter.

# constants.py

BASE_URI = "https://chat.botpress.cloud"
HEADERS = {
   "accept": "application/json",
   "Content-Type": "application/json",
}

2. Create the Request methods

   def _request(self, method, path, json=None):
       url = f"{self.base_url}{path}"
       try:
           response = requests.request(method, url, headers=self.headers, json=json)
           response.raise_for_status()
           return response.json()
       except requests.HTTPError:
           return response.status_code, response.text


   # --- Core API Methods ---


   def get_user(self):
       return self._request("GET", "/users/me")


   def create_user(self, name, id):
       user_data = {"name": name, "id": id}
       return self._request("POST", "/users", json=user_data)


   def set_user_key(self, key):
       self.user_key = key
       self.headers["x-user-key"] = key


   def create_and_set_user(self, name, id):
       new_user = self.create_user(name, id)
       self.set_user_key(new_user["key"])


   def create_conversation(self):
       return self._request("POST", "/conversations", json={"body": {}})


   def list_conversations(self):
       return self._request("GET", "/conversations")


   def get_conversation(self, conversation_id):
       return self._request("GET", f"/conversations/{conversation_id}")


   def create_message(self, message, conversation_id):
       payload = {
           "payload": {"type": "text", "text": message},
           "conversationId": conversation_id,
       }
       return self._request("POST", "/messages", json=payload)


   def list_messages(self, conversation_id):
       return self._request("GET", f"/conversations/{conversation_id}/messages")

As mentioned, nearly all of these map to an endpoint in the API. I’m just wrapping them in a class.

3. Create an SSE Listener

This is the extent of the hackery. To listen for conversation updates and loop into a Streamlit front-end, the client needs a method to listen for– and yield– server-sent events from our bot.

 def listen_conversation(self, conversation_id):
       url = f"{self.base_url}/conversations/{conversation_id}/listen"
       for event in sseclient.SSEClient(url, headers=self.headers):
           print(event.data)
           if event.data == "ping":
               continue
           data = json.loads(event.data)["data"]
	    yield {"id": data["id"], "text": data["payload"]["text"]}

This function takes the conversation_id (which will be accessed programmatically within the app) and yields incoming data as it happens.

1. Adapt the boilerplate code

In theory, you can get the app working with minimal changes to the boilerplate in the Streamlit example.

# app.py


from client import BotpressClient
import streamlit as st
from constants import CONVERSATION_ID


st.title("Botpress Front-end for Streamlit")


client = BotpressClient(
   api_id=st.secrets["CHAT_API_ID"], user_key=st.secrets["USER_KEY"]
)


if "messages" not in st.session_state:
   messages = client.list_messages(CONVERSATION_ID)
   next_token = messages["meta"]["nextToken"]
   st.session_state.messages = messages["messages"][::-1]


for message in st.session_state.messages:
   with st.chat_message(message["userId"]):
       st.markdown(message["payload"]["text"])


if prompt := st.chat_input("*wine*-d it up"):
   st.session_state.messages.append({"role": "user", "content": prompt})


   with st.chat_message("user"):
       st.markdown(prompt)


   client.create_message(prompt, conversation_id=CONVERSATION_ID)
  
   with st.chat_message("assistant"):
response_box = st.empty()
       last_rendered = ""
	
       for message in client.listen_conversation(CONVERSATION_ID):


           message_id = message["id"]
           message_text = message["text"]


           if message_id != last_rendered:
               last_rendered = message_id
               response_box.markdown(message_text)
               st.session_state.messages.append(
                   {"role": "assistant", "content": message_text}
               )

We’re reading secret variables here. So create a .streamlit/secrets.toml file and place your variables inside:

CHAT_API_ID = ”YOUR_API_ID”
USER_KEY = ”YOUR_USER_KEY”

The heavy lifting is happening in:

with st.chat_message("assistant"):
response_box = st.empty()
       last_rendered = ""
	
       for message in client.listen_conversation(CONVERSATION_ID):


           message_id = message["id"]
           message_text = message["text"]


           if message_id != last_rendered:
               last_rendered = message_id
               response_box.markdown(message_text)
               st.session_state.messages.append(
                   {"role": "assistant", "content": message_text}
               )

where the client is latching to the chat elements to deliver and receive messages.

This works, but this isn’t ideal for a few reasons:

• You have to have created a new conversation separately.
• Old messages will be formatted differently from new ones, because they don’t have the role designation (user or assistant).
• You can’t toggle conversations.

2. Create conversations dynamically

Starting from scratch, I’ll automatically create a new conversation or open the most recent one:

# app.py


from client import BotpressClient
import streamlit as st


st.title("Botpress Front-end for Streamlit")


client = BotpressClient(
   api_id=st.secrets["CHAT_API_ID"], user_key=st.secrets["users"][0]["key"]
)


# user info
user = client.get_user()
user_id = user["user"]["id"]


conversations = client.list_conversations()["conversations"]
conversation_ids = [conv["id"] for conv in conversations]




# conversation
def create_conversation():
   res = client.create_conversation()
   print(f"Created new conversation: {res}")
   conversation_id = res["conversation"]["id"]
   st.session_state.active_conversation = conversation_id
   st.session_state.messages = []
   st.rerun()




if not conversations:
   create_conversation()


if "active_conversation" not in st.session_state:
   st.session_state["active_conversation"] = conversations[0]["id"]

Note that I’ve modified the secret keys to be able to store multiple users. You’ll want to modify your .streamlit/secrets.toml file to reflect that:

[[users]]
key = "your_user_key"

You can repeat this block as much as you’d like, storing users as an array of tables.

3. Let users create and toggle between conversations

Like the heading says, this creates a dropdown at the top with a button to let you choose your conversation.

col1, col2 = st.columns([5, 1])
with col1:
   conversation_id = st.selectbox(
       "Select Conversation",
       options=[conv["id"] for conv in conversations],
       index=conversation_ids.index(st.session_state.active_conversation),
   )


with col2:
   st.markdown("<div style='height: 1.9em'></div>", unsafe_allow_html=True)
   if st.button("➕"):
       create_conversation()


selected_conversation = client.get_conversation(conversation_id)

4. Assign the correct role for past messages

We’ll solve the formatting issue from above by assigning the user or assistant role to each of the past messages:

if (
   "messages" not in st.session_state
   or st.session_state.get("active_conversation") != conversation_id
):
   st.session_state.active_conversation = conversation_id
   st.session_state.messages = []


   messages = client.list_messages(conversation_id)
   next_token = messages["meta"].get("nextToken")


   for message in messages["messages"][::-1]:
       role = "user" if message["userId"] == user_id else "assistant"
       text = message["payload"]["text"]
       st.session_state.messages.append({"role": role, "content": text})

This conforms our code to the structure that Streamlit expects.

5. Add the messaging logic

This is more-or-less the same as before, adapted for the new structure.

# display chat history
for message in st.session_state.messages:
   with st.chat_message(message["role"]):
       st.markdown(message["content"])


if prompt := st.chat_input("*wine*-d it up"):


   st.session_state.messages.append({"role": "user", "content": prompt})
   client.create_message(prompt, conversation_id=conversation_id)


   with st.chat_message("user"):
       st.markdown(prompt)


   with st.chat_message("assistant"):
       stream = client.listen_conversation(conversation_id=conversation_id)
       response = st.write_stream(stream)


   st.session_state.messages.append({"role": "assistant", "content": response})

5. Create a user

The logic is ready, but you’ll need to create a user to run the app. I chose to add this separately to simulate the experience of signing up for a service. Fortunately for you, I also wrote a script:

# create_user.py


import argparse
from pathlib import Path
from client import *
from constants import *

secrets_path = Path(".streamlit") / "secrets.toml"

template = """[[users]]
key="{}"

"""

client = BotpressClient()

def create_user(name, id, add_to_secrets=True):
   res = client.create_user(name, id)
   if not add_to_secrets:
       return res

   secrets_path.touch(exist_ok=True)

   with open(secrets_path, "a") as f:
       f.write(template.format(res["user"]["id"], res["key"]))

   return res


if __name__ == "__main__":
   parser = argparse.ArgumentParser(
       description="Create a Botpress user and optionally store secrets."
   )
   parser.add_argument("--name", required=True, help="Display name of the user.")
   parser.add_argument(
       "--id", required=True, help="User ID. If omitted, one is generated by the API."
   )
   parser.add_argument("--chat_api_id", help="ID for the Botpress Chat API integration. Taken from `.env` file if not provided.")
   parser.add_argument(
       "--no-secrets",
       action="store_true",
       help="Do not append to .streamlit/secrets.toml.",
   )

   args = parser.parse_args()

   print(f"Creating user: {args.name} (ID: {args.id or 'auto-generated'})")
   result = create_user(name=args.name, id=args.id, add_to_secrets=not args.no_secrets)

   print("✅ User created:")
   print(result)

Provided you have your Chat API ID, you can run:

python create_user.py –name YOUR_NAME –id SOME_USER_ID –chat_api_id YOUR_CHAT_API_ID

This will deal with creating the user and adding it to your secrets file.

Why would I choose Streamlit over other front-end frameworks for building a chatbot?

You’d choose Streamlit for building a chatbot if you want a fast, Python-based solution that lets you prototype interactive apps quickly without needing front-end expertise, since it handles UI elements like chat components and state management with minimal code.

Is a Streamlit chatbot suitable for production use or just for prototypes?

A Streamlit chatbot is great for prototypes and internal tools, but for public-facing production apps with heavy traffic or advanced styling, you may need additional layers like reverse proxies, security hardening, and possibly a more robust front-end framework to handle scale.

How customizable is the look and feel of a chatbot built with Streamlit?

While Streamlit lets you adjust basic styling like colors, fonts, and layout, it’s less flexible than traditional web frameworks; for truly custom designs, you’d need to embed custom HTML/CSS or JavaScript, which can be done but adds complexity compared to using Streamlit’s built-in widgets.

Can I integrate a Streamlit chatbot into an existing website, or does it have to run standalone?

A Streamlit chatbot typically runs as a standalone web app on its own URL, but you can embed it into an existing website via an iframe, though this requires handling styling and security considerations to make the embedded experience seamless for users.

How much does it cost to deploy a Streamlit chatbot for public use?

Deploying a Streamlit chatbot can be free if hosted locally or on Streamlit Community Cloud for smaller apps, but for public use at scale, costs range from around $5–$50 per month on cloud platforms like Heroku, AWS, or DigitalOcean, depending on traffic and uptime requirements.