I built a small chatbot with DeepSeek-R1 because I wanted to see how a local reasoning model behaved when its intermediate output was made visible. The useful parts were the setup decisions, the strange mistakes, and the few things I would change next time.

DeepSeek being open source was the main reason I wanted to try it. I did not need to wait for an API account or a company to decide how I could use the model. I could download it, tinker with it, and see what happened.

So I went ahead and built the chatbot I had wanted to make for a long time. It is not packed with fancy features yet, but the experiment gave me a better feel for how DeepSeek R1 behaves. You can try it out live here.

The technical details are below.

Showing the model's reasoning output

The part I found most surprising was separating the model’s reasoning output from its final response. In a conventional chatbot, the answer appears without the intermediate work. Here, the model produces a visible sequence of reasoning before the final response, so I could watch it break down a problem and revise its answer. I had not seen that behaviour in the other LLMs I had used.

At first, I didn’t plan for this feature. It appeared while I was testing different ways to improve response quality. I noticed that the model was generating hidden reasoning steps before its final output. Instead of discarding them, I decided to show them. The result made the AI feel more transparent, almost like it was thinking out loud.

For example, if you ask it something like, “What do you think about climate change in Malaysia?”, you won’t just get a final answer out of nowhere. You’ll actually see the model go through a step-by-step breakdown of its thought process:

1. Breaking down the question components
2. Evaluating current knowledge
3. Forming logical connections
4. Combining the pieces into a response

The response was often structured. It analysed the question, split it into different angles, and then assembled an answer instead of jumping straight to a conclusion.

That said, while the response does sound solid, there are some oddities that make me wonder what’s going on under the hood. For example, it mentions “the subtropical Andaman and Nicobar Islands,” which, uh, aren’t even part of Malaysia. Also, “Ch bamboo” initiative? Never heard of that one. These small but noticeable mistakes show that while the model is good at structuring its answers, it still struggles with factual accuracy.

But that’s exactly what makes having a visible thought process so useful. Instead of just blindly trusting AI responses, we can now see how the model arrives at its conclusions, which means we can spot errors more easily. If it had hallucinated this stuff in a normal chatbot, I might not have even noticed. But because I can watch it reason through the problem, I can tell where things might be going wrong.

Seeing the intermediate output also made mistakes easier to catch. I could inspect the path to an answer, correct the prompt, and compare the next response instead of treating the final text as unexplained output.

Deployment Specifications

The chatbot is currently hosted on Hugging Face Spaces, running on a basic-tier instance, which means it’s not exactly a powerhouse but still gets the job done. Here’s what it’s running on:

• CPU: 2 vCPUs
• RAM: 16GB
• Storage: Basic instance storage
• Framework: Gradio
• Inference Optimization: FP16 quantization
• Average Response Time: 2-3 seconds
• Concurrent Users Supported: Up to 10

You might notice that the live preview here can be a bit slow while generating responses. That’s because the hardware isn’t optimized for LLM inference, so it’s working with some limitations. Hope you can bear with it! 😆

Efficient Model Architecture

The chatbot uses the DeepSeek R1 Distilled 1.5B model, a compressed version of the original 685B parameter model. Despite having only 1.5 billion parameters, it reports strong results on several reasoning tasks.

Key points about the model:

• Original model: DeepSeek R1 (685B)
• Distilled version: DeepSeek R1 Distill Qwen 1.5B
• 440x parameter reduction while maintaining core capabilities

Benchmark results

The model holds up well against much larger models on several published benchmarks, although that does not make it the best choice for every task.

Selected results

1. AIME 2024 (Math Competition)
   • DeepSeek R1 Distilled: 28.9% Pass@1
   • GPT-4o: 9.3% Pass@1
   • Claude 3.5: 16.0% Pass@1
2. MATH-500 (Mathematical Reasoning)
   • DeepSeek R1 Distilled: 83.9% Pass@1
   • GPT-4o: 74.6% Pass@1
   • Claude 3.5: 78.3% Pass@1
3. Codeforces (Competitive Programming)
   • DeepSeek R1 Distilled: 954 Rating
   • GPT-4o: 759 Rating
   • Claude 3.5: 717 Rating

Model Strengths & Limitations

Strengths:

• Superior reasoning capabilities, especially in mathematics
• Highly efficient with only 1.5B parameters
• Effective knowledge distillation from larger models
• Excellent performance in zero-shot scenarios

Limitations:

• Lower performance in general coding tasks
• Potential language mixing issues
• Sensitivity to prompt formatting
• Limited performance in broader general knowledge tasks

This balanced perspective shows why I chose this model for my chatbot implementation - it provides exceptional reasoning capabilities while remaining lightweight enough for practical deployment.

Try It Yourself

Due to iframe restrictions, you can access the live demo through these methods:

1. Direct Link to Demo
2. Docker Spaces documentation
3. Source Code

What I learned

DeepSeek made it easier for me to experiment with a capable reasoning model without relying on a paid API. The open-source release also meant I could inspect the model card, run a local or hosted version, and change the interface around it.

My chatbot is still small and not feature-packed, but it gave me a practical way to study the model's reasoning output and its failure modes. You can try it out live here.

Additional Resources

• Model Card
• Deployment Guide
• Performance Benchmarks
• Community Discussion

References

1. DeepSeek R1 (685B)
   The original DeepSeek R1 model, a large-scale AI model with 685 billion parameters, was the precursor to the distilled 1.5B version used in the chatbot.
   Source
2. DeepSeek R1 Distill Qwen 1.5B
   This is the distilled version of the DeepSeek R1 model, compressed to 1.5 billion parameters while retaining core capabilities.
   Source
3. Open R1 Model Architecture
   Explore the detailed architecture of the DeepSeek R1 model, showcasing its design and structure.
   Source
4. Medium - Deepseek R1 Distill Qwen 1.5B Performance
   A comparison of the performance between Deepseek R1 Distilled and other models, showing its impressive results in multiple domains.
   Source
5. Hugging Face Space - Chatbot Demo
   Live demo of the Deepseek R1 chatbot that showcases the model’s response and reasoning capabilities.
   Source
6. Hugging Face - API Documentation
   Official API documentation for Hugging Face Spaces, helping developers interact with models and integrate them into applications.
   Source
7. Hugging Face - Source Code
   Direct access to the source code of the Deepseek R1 chatbot project on Hugging Face Spaces for those interested in contributing or learning.
   Source
8. Hugging Face - Model Card
   Official card for the Deepseek R1 Distilled model, providing details on its functionality and training specifications.
   Source
9. Hugging Face - Deployment Guide
   Guidelines for deploying models and applications using Hugging Face Spaces.
   Source
10. Hugging Face - Performance Benchmarks
    An overview of the model performance across various tasks and benchmarks, showcasing the strengths and weaknesses of different models.
    Source
11. Hugging Face - Community Discussion
    Join the community discussions on Hugging Face, where users can ask questions, share insights, and discuss AI-related topics.
    Source