Upload 10 files

app (1).py

@@ -0,0 +1,128 @@
+import streamlit as st
+import requests
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Page configuration
+st.set_page_config(
+    page_title="DeepSeek Chatbot - ruslanmv.com",
+    page_icon="🤖",
+    layout="centered"
+)
+
+# Initialize session state for chat history
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# 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 created by ruslanmv.com. Provide clear, accurate, and brief answers. Keep responses polite, engaging, and to the point. 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
+    )
+
+# Function to query the 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
+
+# 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"])
+
+# 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}")
+
+            # 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]:
+                    # Extract the assistant's response
+                    assistant_response = output[0]['generated_text'].strip()
+
+                    # Check for and remove duplicate responses
+                    responses = assistant_response.split("\n</think>\n")
+                    unique_response = responses[0].strip()
+
+                    logger.info(f"Generated response: {unique_response}")
+
+                    # Append response to chat only once
+                    with st.chat_message("assistant"):
+                        st.markdown(unique_response)
+
+                    st.session_state.messages.append({"role": "assistant", "content": unique_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)}")

app-v3-working-dup.py

@@ -0,0 +1,121 @@
+import streamlit as st
+import requests
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Page configuration
+st.set_page_config(
+    page_title="DeepSeek Chatbot - ruslanmv.com",
+    page_icon="🤖",
+    layout="centered"
+)
+
+# Initialize session state for chat history
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# 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 created by ruslanmv.com. Provide clear, accurate, and brief answers. Keep responses polite, engaging, and to the point. 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
+    )
+
+# Function to query the 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
+
+# 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"])
+
+# 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)}")

app-work-only-1.py

@@ -0,0 +1,214 @@
+
+import streamlit as st
+import requests
+
+# Function to query the Hugging Face API
+def query(payload, api_url):
+    headers = {"Authorization": f"Bearer {st.secrets['HF_TOKEN']}"}
+    response = requests.post(api_url, headers=headers, json=payload)
+    return response.json()
+
+# Page configuration
+st.set_page_config(
+    page_title="DeepSeek Chatbot - ruslanmv.com",
+    page_icon="🤖",
+    layout="centered"
+)
+
+# Initialize session state for chat history
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+if "selected_model" not in st.session_state:
+    st.session_state.selected_model = "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"
+
+# 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",
+        "deepseek-ai/DeepSeek-R1",
+        "deepseek-ai/DeepSeek-R1-Zero"
+    ]
+    selected_model = st.selectbox("Select Model", model_options, index=model_options.index(st.session_state.selected_model))
+    st.session_state.selected_model = selected_model
+
+    system_message = st.text_area(
+        "System Message",
+        value="You are a friendly Chatbot created by ruslanmv.com",
+        height=100
+    )
+
+    max_tokens = st.slider(
+        "Max Tokens",
+        1, 4000, 512
+    )
+
+    temperature = st.slider(
+        "Temperature",
+        0.1, 4.0, 0.7
+    )
+
+    top_p = st.slider(
+        "Top-p",
+        0.1, 1.0, 0.9
+    )
+
+# 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"])
+
+# 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
+            payload = {
+                "inputs": prompt,
+                "parameters": {
+                    "max_new_tokens": max_tokens,
+                    "temperature": temperature,
+                    "top_p": top_p,
+                    "return_full_text": False
+                }
+            }
+
+            # Query the Hugging Face API using the selected model
+            api_url = f"https://api-inference.huggingface.co/models/{st.session_state.selected_model}"
+            output = query(payload, api_url)
+
+            # Handle API response
+            if isinstance(output, list) and len(output) > 0 and 'generated_text' in output[0]:
+                assistant_response = output[0]['generated_text']
+
+                with st.chat_message("assistant"):
+                    st.markdown(assistant_response)
+
+                st.session_state.messages.append({"role": "assistant", "content": assistant_response})
+            else:
+                st.error("Error: Unable to generate a response. Please try again.")
+
+    except Exception as e:
+        st.error(f"Application Error: {str(e)}")
+
+'''
+
+import streamlit as st
+import requests
+
+# Hugging Face API URL (default model)
+API_URL = "https://api-inference.huggingface.co/models/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"
+
+# Function to query the Hugging Face API
+def query(payload, api_url):
+    headers = {"Authorization": f"Bearer {st.secrets['HF_TOKEN']}"}
+    response = requests.post(api_url, headers=headers, json=payload)
+    return response.json()
+
+# Page configuration
+st.set_page_config(
+    page_title="DeepSeek Chatbot - ruslanmv.com",
+    page_icon="🤖",
+    layout="centered"
+)
+
+# Initialize session state for chat history
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# 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",
+        "deepseek-ai/DeepSeek-R1",
+        "deepseek-ai/DeepSeek-R1-Zero"
+    ]
+    selected_model = st.selectbox("Select Model", model_options, index=0)
+
+    system_message = st.text_area(
+        "System Message",
+        value="You are a friendly Chatbot created by ruslanmv.com",
+        height=100
+    )
+
+    max_tokens = st.slider(
+        "Max Tokens",
+        1, 4000, 512
+    )
+
+    temperature = st.slider(
+        "Temperature",
+        0.1, 4.0, 0.7
+    )
+
+    top_p = st.slider(
+        "Top-p",
+        0.1, 1.0, 0.9
+    )
+
+# 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"])
+
+# 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
+            payload = {
+                "inputs": prompt,
+                "parameters": {
+                    "max_new_tokens": max_tokens,
+                    "temperature": temperature,
+                    "top_p": top_p,
+                    "return_full_text": False
+                }
+            }
+
+            # Query the Hugging Face API using the selected model
+            output = query(payload, f"https://api-inference.huggingface.co/models/{selected_model}")
+
+            # Handle API response
+            if isinstance(output, list) and len(output) > 0 and 'generated_text' in output[0]:
+                assistant_response = output[0]['generated_text']
+
+                with st.chat_message("assistant"):
+                    st.markdown(assistant_response)
+
+                st.session_state.messages.append({"role": "assistant", "content": assistant_response})
+            else:
+                st.error("Error: Unable to generate a response. Please try again.")
+
+    except Exception as e:
+        st.error(f"Application Error: {str(e)}")
+
+
+
+
+'''

app-working-v2.py

@@ -0,0 +1,116 @@
+
+import streamlit as st
+import requests
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Page configuration
+st.set_page_config(
+    page_title="DeepSeek Chatbot - ruslanmv.com",
+    page_icon="🤖",
+    layout="centered"
+)
+
+# Initialize session state for chat history
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# 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",
+     #   "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
+     #   "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
+     #   "deepseek-ai/DeepSeek-R1-Distill-Llama-70B", 
+     #   "deepseek-ai/DeepSeek-R1-Distill-Llama-8B"
+    ]
+    selected_model = st.selectbox("Select Model", model_options, index=0)
+
+    system_message = st.text_area(
+        "System Message",
+        value="You are a friendly Chatbot created by ruslanmv.com",
+        height=100
+    )
+
+    max_tokens = st.slider(
+        "Max Tokens",
+        1, 4000, 512
+    )
+
+    temperature = st.slider(
+        "Temperature",
+        0.1, 4.0, 0.7
+    )
+
+    top_p = st.slider(
+        "Top-p",
+        0.1, 1.0, 0.9
+    )
+
+# Function to query the 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}")
+    return response.json()
+
+# 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"])
+
+# 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
+            payload = {
+                "inputs": 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}")
+
+            # Query the Hugging Face API using the selected model
+            output = query(payload, api_url)
+
+            # Handle API response
+            if isinstance(output, list) and len(output) > 0 and '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: {output}")
+                st.error("Error: Unable to generate a response. Please try again.")
+
+    except Exception as e:
+        logger.error(f"Application Error: {str(e)}", exc_info=True)
+        st.error(f"Application Error: {str(e)}")

app_base.py

@@ -0,0 +1,29 @@
+import streamlit as st
+import requests
+
+# Hugging Face API URL
+API_URL = "https://api-inference.huggingface.co/models/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"
+
+# Function to query the Hugging Face API
+def query(payload):
+    headers = {"Authorization": f"Bearer {st.secrets['HF_TOKEN']}"}
+    response = requests.post(API_URL, headers=headers, json=payload)
+    return response.json()
+
+# Streamlit app
+st.title("DeepSeek-R1-Distill-Qwen-32B Chatbot")
+
+# Input text box
+user_input = st.text_input("Enter your message:")
+
+if user_input:
+    # Query the Hugging Face API with the user input
+    payload = {"inputs": user_input}
+    output = query(payload)
+    
+    # Display the output
+    if isinstance(output, list) and len(output) > 0 and 'generated_text' in output[0]:
+        st.write("Response:")
+        st.write(output[0]['generated_text'])
+    else:
+        st.write("Error: Unable to generate a response. Please try again.")

models.py

@@ -0,0 +1,4 @@
+import os
+
+def get_hf_api():
+    return "https://api-inference.huggingface.co/models/deepseek-ai/DeepSeek-R1"

models1.py

@@ -0,0 +1,22 @@
+# models.py
+
+import gradio as gr
+import spaces
+import types
+
+# Create a local "transformers_gradio" object to mimic the missing package
+transformers_gradio = types.SimpleNamespace(registry="huggingface")
+
+# Now the gradio.load calls will work as if we had `import transformers_gradio`
+demo = gr.load(name="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B", src=transformers_gradio.registry)
+demo = gr.load(name="deepseek-ai/DeepSeek-R1", src=transformers_gradio.registry)
+demo = gr.load(name="deepseek-ai/DeepSeek-R1-Zero", src=transformers_gradio.registry)
+
+# Example of using spaces (assuming `spaces.GPU()` is valid in your environment)
+demo.fn = spaces.GPU()(demo.fn)
+
+for fn in demo.fns.values():
+    fn.api_name = False
+
+if __name__ == "__main__":
+    demo.launch()

old.py

@@ -0,0 +1,109 @@
+import streamlit as st
+from models import demo  # Import the demo object from models.py
+
+# --- Streamlit App Configuration ---
+st.set_page_config(
+    page_title="DeepSeek Chatbot",
+    page_icon="🤖",
+    layout="wide"
+)
+
+# --- App Title and Description ---
+st.title("DeepSeek Chatbot")
+st.markdown("""
+    Created by [ruslanmv.com](https://ruslanmv.com/)
+    This is a demo of different DeepSeek models. Select a model, type your message, and click "Submit".
+    You can also adjust optional parameters like system message, max new tokens, temperature, and top-p.
+""")
+
+# --- Sidebar for Model Selection and Parameters ---
+with st.sidebar:
+    st.header("Options")
+    model_choice = st.radio(
+        "Choose a Model",
+        options=["DeepSeek-R1-Distill-Qwen-32B", "DeepSeek-R1", "DeepSeek-R1-Zero"],
+        index=1  # Default to "DeepSeek-R1"
+    )
+    
+    with st.expander("Optional Parameters", expanded=False):
+        system_message = st.text_area(
+            "System Message",
+            value="You are a friendly Chatbot created by ruslanmv.com",
+            height=100
+        )
+        max_new_tokens = st.slider(
+            "Max New Tokens",
+            min_value=1,
+            max_value=4000,
+            value=200
+        )
+        temperature = st.slider(
+            "Temperature",
+            min_value=0.10,
+            max_value=4.00,
+            value=0.70
+        )
+        top_p = st.slider(
+            "Top-p (nucleus sampling)",
+            min_value=0.10,
+            max_value=1.00,
+            value=0.90
+        )
+
+# --- Chatbot Function ---
+def chatbot(input_text, history, model_choice, system_message, max_new_tokens, temperature, top_p):
+    # Create payload for the model
+    payload = {
+        "messages": [{"role": "user", "content": input_text}],
+        "system": system_message,
+        "max_tokens": max_new_tokens,
+        "temperature": temperature,
+        "top_p": top_p
+    }
+    
+    # Run inference using the selected model
+    try:
+        response = demo(payload)  # Use the demo object directly
+        if isinstance(response, dict) and "choices" in response:
+            assistant_response = response["choices"][0]["message"]["content"]
+        else:
+            assistant_response = "Unexpected model response format."
+    except Exception as e:
+        assistant_response = f"Error: {str(e)}"
+    
+    # Append user and assistant messages to history
+    history.append((input_text, assistant_response))
+    return history
+
+# --- Chat History Management ---
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+
+# --- Chat Interface ---
+st.header("Chat with DeepSeek")
+
+# Display chat history
+for user_msg, assistant_msg in st.session_state.chat_history:
+    with st.chat_message("user"):
+        st.write(user_msg)
+    with st.chat_message("assistant"):
+        st.write(assistant_msg)
+
+# Input for new message
+input_text = st.chat_input("Type your message here...")
+
+# Handle new message submission
+if input_text:
+    # Update chat history
+    st.session_state.chat_history = chatbot(
+        input_text,
+        st.session_state.chat_history,
+        model_choice,
+        system_message,
+        max_new_tokens,
+        temperature,
+        top_p
+    )
+    
+    # Rerun the app to display the updated chat history
+    st.rerun()

old2.py

@@ -0,0 +1,127 @@
+# app.py
+import streamlit as st
+from huggingface_hub import InferenceClient
+from datetime import datetime
+
+# Configure page
+st.set_page_config(
+    page_title="DeepSeek Chatbot - ruslanmv.com",
+    page_icon="🤖",
+    layout="centered",
+    initial_sidebar_state="expanded"
+)
+
+# Initialize session state
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# Sidebar controls
+with st.sidebar:
+    st.title("🤖 Chatbot Settings")
+    st.markdown("Created by [ruslanmv.com](https://ruslanmv.com/)")
+    
+    # Model selection
+    selected_model = st.selectbox(
+        "Choose Model",
+        options=[
+            "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
+            "deepseek-ai/DeepSeek-R1",
+            "deepseek-ai/DeepSeek-R1-Zero"
+        ],
+        index=0
+    )
+    
+    # System message
+    system_message = st.text_area(
+        "System Message",
+        value="You are a friendly Chatbot created by ruslanmv.com",
+        height=100
+    )
+    
+    # Generation parameters
+    max_new_tokens = st.slider(
+        "Max new tokens",
+        min_value=1,
+        max_value=4000,
+        value=512,
+        step=50
+    )
+    
+    temperature = st.slider(
+        "Temperature",
+        min_value=0.1,
+        max_value=4.0,
+        value=1.0,
+        step=0.1
+    )
+    
+    top_p = st.slider(
+        "Top-p (nucleus sampling)",
+        min_value=0.1,
+        max_value=1.0,
+        value=0.9,
+        step=0.1
+    )
+    
+    # Optional HF Token
+    hf_token = st.text_input(
+        "HuggingFace Token (optional)",
+        type="password",
+        help="Enter your HuggingFace token if required for model access"
+    )
+
+# Main chat interface
+st.title("💬 DeepSeek Chatbot")
+st.caption("🚀 A conversational AI powered by DeepSeek models")
+
+# Display chat messages
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+        if "timestamp" in message:
+            st.caption(f"_{message['timestamp']}_")
+
+# Chat input and processing
+if prompt := st.chat_input("Type your message..."):
+    # Add user message to history
+    st.session_state.messages.append({
+        "role": "user",
+        "content": prompt,
+        "timestamp": datetime.now().strftime("%H:%M:%S")
+    })
+    
+    # Display user message
+    with st.chat_message("user"):
+        st.markdown(prompt)
+        st.caption(f"_{st.session_state.messages[-1]['timestamp']}_")
+
+    # Create full prompt with system message
+    full_prompt = f"{system_message}\n\nUser: {prompt}\nAssistant:"
+    
+    # Create client and generate response
+    client = InferenceClient(model=selected_model, token=hf_token)
+    
+    # Display assistant response
+    with st.chat_message("assistant"):
+        response = st.write_stream(
+            client.text_generation(
+                full_prompt,
+                max_new_tokens=max_new_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                stream=True
+            )
+        )
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        st.caption(f"_{timestamp}_")
+
+    # Add assistant response to history
+    st.session_state.messages.append({
+        "role": "assistant",
+        "content": response,
+        "timestamp": timestamp
+    })
+
+# Optional debug information
+# st.sidebar.markdown("---")
+# st.sidebar.json(st.session_state.messages)

requirements (1).txt

@@ -0,0 +1,2 @@
+huggingface_hub==0.25.2
+transformers