In this blog, I will walk you through the process of setting up DeepSeek R1 on my local machine. This guide includes my motivations for running DeepSeek locally, the setup steps, and insights into my implementation.

What is DeepSeek?

DeepSeek is a reasoning model enhanced with reinforcement learning. This means it can think logically, verify its own thought process, and produce more accurate results over time.

Why I Chose to Run DeepSeek Locally

There are several key reasons why I chose to run DeepSeek on my own machine rather than using an online AI service:

1. Data Privacy: Owning my data is a top priority. Using online AI models such as ChatGPT, Gemini, or others involves sending data to third-party providers, where it may be collected and used as they see fit. Running DeepSeek locally ensures that my data remains private and under my control.

2. Sense of Ownership: DeepSeek is open-source, and the ability to download and customize it gives me a deep sense of ownership and control over how I use it.

3. Freedom & Flexibility: Running DeepSeek locally means no restrictions or limitations—apart from hardware constraints. This allows me to explore different creative possibilities without external constraints.

Setup Process

1. Downloading the Required Tools

First, I downloaded Ollama, a tool that facilitates the management and execution of AI models locally.

Next, I used PowerShell to download DeepSeek R1 from this link using the following command:

2. Running DeepSeek Locally

Once the model was successfully downloaded, I could run it using:

However, my goal was not just to run it from the command line but to build a local AI-powered application. To achieve this, I needed a way to interact with the model programmatically.

Building a Local UI for DeepSeek

To integrate DeepSeek into a local application, I used Python for backend interactions and Streamlit to create a simple user interface.

1. Installing Required Libraries

I installed the ollama Python package to communicate with DeepSeek:

I also installed Streamlit for building the UI:

To confirm Streamlit was installed correctly, I ran:

Interacting with DeepSeek Programmatically

After setting up the required libraries, I began working on the interaction logic between the user input and the AI model. I used st.chat_input to take user input:

prompt = st.chat_input("Say something")
prevMsg = ''

Then, I sent the input to DeepSeek for processing:

if prompt:
  stream = chat(
      model='deepseek-r1:8b',
      messages= content + [{'role': 'user', 'content': prompt}],
      stream=True)
 
  def stream_data():
    global prevMsg
    for chunk in stream:
      content = chunk['message']['content']
      yield content

Storing Conversations Locally

Instead of using a database, I decided to store conversations in JSON files since I'm the only one using the system for now. Here’s how I handled saving chat history:

def save_file(file_name: str):
    content = read_file(file_name)
 
    if not len(content):
        handle_set_new_chat()
        content.append(ai_system)
        handle_save_chat_title_and_index(user['content'], file_name)
        
    content.append(user)
    content.append(assistant)
 
    with open(file_name, 'w+', encoding='utf-8') as f:
        json.dump(content, f)
    f.close()
    st.session_state['allChats'] = get_all_chats()

Managing Chat History

To enable browsing past conversations, I stored each user input as a user object and each AI response as an assistant object:

user = {}
assistant = {}
 
def handle_chats(question: str, answer: str):
    user['role'] = 'user'
    user['content'] = question
 
    assistant['role'] = 'assistant'
    assistant['content'] = answer

To create new chat sessions, I introduced a system role to indicate a fresh conversation:

def handle_set_new_chat():
    ai_system['role'] = 'system'
    ai_system['content'] = 'New chat'

Finally, I displayed saved chats in the sidebar:

with st.sidebar:
    all_chats = st.session_state['allChats']
    chat_length = len(all_chats)
    
    if st.button('Add new', type='primary', use_container_width=True):
        handle_new_chat(f'chat{chat_length + 1}.json')
    
    for c in all_chats:
        title = c['title']
        fileName = c['fileName']
 
        if len(title) > 30:
            title = title[:30] + '...'
        if st.button(title, key=title + fileName, use_container_width=True):
            handle_new_chat(fileName)

Conclusion

Setting up DeepSeek R1 locally was a great learning experience. Running my own AI model gives me full control over my data, fosters creativity, and eliminates reliance on third-party services.

For anyone interested in doing the same, I found this GitHub discussion helpful.

The full source code can be found here.

Thanks for reading!