Skip to main content

How to Create an AI Chatbot App Using DeepSeek-R1 ?

Now a days Chinese AI company DeepSeek is getting popularity due to it's AI model DeepSeek-R1. So, I decided to try this DeepSeek-R1 model and develop a chatbot app this is why I am creating this tutorial. In this step by step tutorial I am going to show you how you can create an AI Chatbot App using DeepSeek-R1 model. For the development of the chatbot application I am going to use Streamlit python web development framework. With the help of Streamlit python package you can develop entire chatbot application only with python programming language.

Prerequisites

Before we start the development of our chatbot application. We need to install the prerequisites/dependencies or the python packages which we need to develop the application. Here is the list of package which we need to install -

  • huggingface_hub==0.25.2
  • transformers
  • streamlit

Note - In order to install these python package make sure that your internet should be up and running. You can install these packages with a single pip command

pip install streamlit transformers huggingface_hub==0.25.2

Hopefully if everything goes well you will see that pip will fetch all the necessary files and install all the packages as shown below.

Coding

In this section we will start the development of our AI chatbot app.

import streamlit as st
import requests
import logging

We will start with importing all the necessary python packages. As you can see in the above section from Line-1 to Line-2 we have imported 3 python packages streamlit,requestsandlogging.

  • streamlit - It will help to create the GUI components of the chatbot app.
  • requests - The requests package will help you send and receive api response from HuggingFace.
  • logging - This package will help you to collect all the log messages generated by our ai chatbot.
# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Page configuration
st.set_page_config(
    page_title="DeepSeek-R1 Chatbot",
    page_icon="🤖",
    layout="centered"
)

Now, after importing all the python packages first we will configure log setting and set initial web page configuration. In the above code section, On Line-2 we have configure the log settings with the help of logging.basicConfig() function. In line-3 we have create a variable named logger which saves the logs coming from logging.getLogger(__name__) function and __name__ is the name of the logger..

# Initialize session state for chat history
if "messages" not in st.session_state:
    st.session_state.messages = []
  • st.session_state is a python data structure(dictionary) offered by Streamlit library to save the data and hold the previous state of the variable while rerun the AI chatbot application. Whenever a user interacts with Streamlit app, it starts execute from top to bottom. So, in this case normal variable won't be able to hold the previous state. In such type of cases st.session_state allows you to perform this kind of operations.
  • In line-2 if "messages" not in st.session_state, this if statement will help you to check whether messages variable have any kind of previous messages or not. If messages variable do not have any kind of previous data then next line of code will be executes.
  • In line-3 st.session_state.messages = [] makes sure if messages variable is empty in st.session_state then it initializes it as an empty list.
# Sidebar configuration
with st.sidebar:
    st.header("Model Configuration")
    st.markdown("[Get HuggingFace Token](https://huggingface.co/settings/tokens)")

    # Dropdown to select model
    model_options = [
        "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    ]
    selected_model = st.selectbox("Select Model", model_options, index=0)

    system_message = st.text_area(
        "System Message",
        value="You are a friendly chatbot which provides clear, accurate, and brief answers. If unsure, politely suggest alternatives.",
        height=100
    )

    max_tokens = st.slider(
        "Max Tokens",
        10, 4000, 100
    )

    temperature = st.slider(
        "Temperature",
        0.1, 4.0, 0.3
    )

    top_p = st.slider(
        "Top-p",
        0.1, 1.0, 0.6
    )

  • In line-2 st.sidebar is a special container in Streamlit that allows you to place GUI elements in a sidebar. The with statement makes sure that all the UI components inside this block will be displayed in the sidebar rather than the main app.

  • In line-3 st.header() function titled "Model Configuration" inside the sidebar. This helps users to understand that the section is for configuring the model settings.

  • Line-4 will give you clickable Markdown link that directs users to Hugging Face’s token page. You need to generate you own unique token in order to use the DeepSeek-R1 models. It is very much useful for those users who need an API token for accessing Hugging Face models.

  • Now create a dropdown (st.selectbox) menu where users can choose one of the models. I am using only one model for the sake of simplicity but you can add other models of DeepSeek-R1 as well. For now, the list model_options contains only one model: "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B" and index=0 means that this model is pre-selected.

  • After that we will creates a text area (st.text_area) where users can edit the system prompt for the chatbot and the value parameter provides a default system message that defines how the chatbot should behave. height=100 sets the height of the text area.

  • Up next we will create a slider (st.slider) that allows users to choose the maximum number of tokens the chatbot should generate and 10 (min), 4000 (max), 100 are the default values.

  • From line-23 to line-26 we will create a slider for setting the temperature, which controls randomness with default values 0.1 (min), 4.0 (max), 0.3.

  • From line-28 to line-30 slider sets Top-p (nucleus sampling), a technique to control response randomness with default values 0.1 (min), 1.0 (max), 0.6.

# Function to send query through Hugging Face API
def query(payload, api_url):
    headers = {"Authorization": f"Bearer {st.secrets['HF_TOKEN']}"}
    logger.info(f"Sending request to {api_url} with payload: {payload}")
    response = requests.post(api_url, headers=headers, json=payload)
    logger.info(f"Received response: {response.status_code}, {response.text}")
    try:
        return response.json()
    except requests.exceptions.JSONDecodeError:
        logger.error(f"Failed to decode JSON response: {response.text}")
        return None

Now the above mention section of code helps you to create a function to send query through Hugging Face API.

  • Now we will create a function named query that takes two parameters. First is payload a dictionary containing the data to send to the API and second one is api_url the URL of the Hugging Face API endpoint. The purpose of this function is to send the payload (such as a chat message or a request for text generation) to the Hugging Face API.

  • Now we will creates a dictionary of headers to be sent with the request. It includes an Authorization token, which is required to authenticate with Hugging Face's API. st.secrets['HF_TOKEN'] retrieves the Hugging Face API token stored securely in Streamlit’s secrets manager. f"Bearer {st.secrets['HF_TOKEN']}" formats the token as required for authentication.

  • Now, logger.info(f"Sending request to {api_url} with payload: {payload}") Logs information about the API request being sent. Helps with debugging by printing the API URL and the request payload.

  • Now, response = requests.post(api_url, headers=headers, json=payload) will uses requests.post() to send the payload to the Hugging Face API. api_url is the endpoint to send the request to, headers is the authentication token. json=payload sends the payload as JSON data. The Hugging Face API requires a POST request to process input and return a response and requests.post() will help you in this.

  • Now, logger.info(f"Received response: {response.status_code}, {response.text}") will logs the status code and response text for debugging. It will also helps identify issues like: 200 OK (Success), 401 Unauthorized (Invalid API token), 500 Internal Server Error (Server issue).

  • Now, the try block will attempt to convert the API response into JSON format and if it is successful then the function returns the parsed JSON. But the question is Why Convert to JSON?. The simple answer is Hugging Face API typically responds with structured JSON data, making it easy to extract model outputs.

  • In the End the except block will work if the response cannot be decoded as JSON, it logs an error. This prevents crashes if the API returns an unexpected format (e.g., an HTML error page instead of JSON). If Hugging Face API returns an error message that isn’t valid JSON, calling .json() would cause a crash.

# Chat interface
st.title("🤖 DeepSeek Chatbot")
st.caption("Powered by Hugging Face Inference API - Configure in sidebar")

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

  • In the above mentioned code st.title() displays a large title with an emoji 🤖 which making the chatbot interface looks good. st.caption() displaying a small caption under the title, providing the extra context and here, it informs users that the chatbot is powered by Hugging Face's API and can be configured via the sidebar. This section of code will sets up the UI header for the our chatbot app.

  • the for loop for message in st.session_state.messages iterates through st.session_state.messages, which stores the chat history. This will help the chatbot to save and display previous messages when the Streamlit app reruns. In the Streamlit package st.session_state is a persistent storage data structure and "messages" variable is a list of dictionaries where each dictionary represents a chat message.

  • Now st.chat_message(role) will creates a chat box based on the message’s "role", if "role" is "user" then the chat box is styled differently from "assistant" messages and st.markdown(message["content"]) will displays the message text inside the chat box. Also, Supports Markdown formatting like bold, italics, links, etc...

# Handle input
if prompt := st.chat_input("Type your message..."):
    st.session_state.messages.append({"role": "user", "content": prompt})

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

    try:
        with st.spinner("Generating response..."):
            # Prepare the payload for the API
            # Combine system message and user input into a single prompt
            full_prompt = f"{system_message}\n\nUser: {prompt}\nAssistant:"
            payload = {
                "inputs": full_prompt,
                "parameters": {
                    "max_new_tokens": max_tokens,
                    "temperature": temperature,
                    "top_p": top_p,
                    "return_full_text": False
                }
            }

            # Dynamically construct the API URL based on the selected model
            api_url = f"https://api-inference.huggingface.co/models/{selected_model}"
            logger.info(f"Selected model: {selected_model}, API URL: {api_url}")
            print("payload",payload)
            # Query the Hugging Face API using the selected model
            output = query(payload, api_url)

            # Handle API response
            if output is not None and isinstance(output, list) and len(output) > 0:
                if 'generated_text' in output[0]:
                    assistant_response = output[0]['generated_text']
                    logger.info(f"Generated response: {assistant_response}")

                    with st.chat_message("assistant"):
                        st.markdown(assistant_response)

                    st.session_state.messages.append({"role": "assistant", "content": assistant_response})
                else:
                    logger.error(f"Unexpected API response structure: {output}")
                    st.error("Error: Unexpected response from the model. Please try again.")
            else:
                logger.error(f"Empty or invalid API response: {output}")
                st.error("Error: Unable to generate a response. Please check the model and try again.")

    except Exception as e:
        logger.error(f"Application Error: {str(e)}", exc_info=True)
        st.error(f"Application Error: {str(e)}")

In the end the above mentioned piece of code is responsible for handling user input in a chatbot interface built with Streamlit python library. It takes the user's message, sends it to a Hugging Face model, retrieves the model's response and displays it in the chat interface. Additionally, it incorporates error handling and logging to ensure the application runs without any crash.

The first part of the code listens for user input,

if prompt := st.chat_input("Type your message..."):

uses the walrus operator (:=), which assigns the input value to prompt while checking if it's non-empty. If the user types a message in the chat input box, it gets stored in prompt. This message is then added to st.session_state.messages, ensuring that it remains visible when Streamlit reruns the script.

After storing the message, it is immediately displayed in the chat interface using:

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

This ensures that the user's message appears on the screen as soon as they send it.

Once the user sends a message, the chatbot needs to generate a response. The application enters a loading state using:

with st.spinner("Generating response..."):

This provides a visual cue to the user that the chatbot is thinking.

To generate a response, the system combines the predefined system message (which defines how the chatbot should behave) with the user's input. The combined prompt follows a conversational format:

full_prompt = f"{system_message}\n\nUser: {prompt}\nAssistant:"

This structure provides context to the model, allowing it to generate coherent replies.

A payload dictionary is then created with the model parameters:

payload = {
    "inputs": full_prompt,
    "parameters": {
        "max_new_tokens": max_tokens,
        "temperature": temperature,
        "top_p": top_p,
        "return_full_text": False
    }
}
  • inputs contains the conversation history to provide context to the model.
  • max_new_tokens limits the response length.
  • temperature controls the randomness of responses (lower values make replies more deterministic).
  • top_p adjusts the probability distribution for sampling words.
  • return_full_text: False ensures that only the generated text is returned, not the full input prompt.

Before sending the request, the code constructs the API URL dynamically based on the selected model:

api_url = f"https://api-inference.huggingface.co/models/{selected_model}"
logger.info(f"Selected model: {selected_model}, API URL: {api_url}")
print("payload",payload)

Logging this information helps with debugging in case something goes wrong.

Next, the function query(payload, api_url) is called, which sends the request to the Hugging Face API and waits for the response.

Once the API returns a response, the code checks if it's valid:

if output is not None and isinstance(output, list) and len(output) > 0:

The Hugging Face API typically returns a list containing a dictionary. The chatbot extracts the generated text:

if 'generated_text' in output[0]:
    assistant_response = output[0]['generated_text']

This is the AI-generated reply. If valid, it is logged and displayed in the chat interface:

with st.chat_message("assistant"):
    st.markdown(assistant_response)

The chatbot's reply is also added to the session state, allowing it to persist when Streamlit refreshes:

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

If the API response structure is incorrect, the chatbot logs an error:

logger.error(f"Unexpected API response structure: {output}")
st.error("Error: Unexpected response from the model. Please try again.")

Similarly, if the response is completely invalid or empty, another error message is displayed:

logger.error(f"Empty or invalid API response: {output}")
st.error("Error: Unable to generate a response. Please check the model and try again.")

If any unexpected errors occur (such as network failures or API timeouts), the except block catches the exception:

except Exception as e:
    logger.error(f"Application Error: {str(e)}", exc_info=True)
    st.error(f"Application Error: {str(e)}")

This last piece of code ensures that users receive a clear error message instead of the application crashing.

Running Streamlit App

In order to run the streamlit AI chabot application please execute the below mention command in the Command Prompt or in Terminal -
>> streamlit run app.py 
Now if everything goes well then you will be able to see your chatbot app running in your default web browser as shown in the below mentioned image or you can also run it inside any browser of you choice through localhost. You can see the localhost ip inside Command Prompt or in Terminal applications.

Labels:

Comments

Post a Comment