Running DeepSeek on Your Computer: A Step-by-Step Guide

If you’ve ever wondered about unlocking the full potential of your Mac mini M4 Pro with DeepSeek R1 models locally, then you’re in for a treat. While your Mac mini may not be able to transform into an LLM powerhouse, it can certainly handle running DeepSeek R1 models without relying on cloud-based AI servers. By utilizing Docker and Open WebUI, you can set up a seamless and ChatGPT-like experience, all while keeping your data private and under your control.

With the right configuration, your Mac mini can take on tasks like fine-tuning, text generation, and retrieval without the need for a dedicated server. Docker and Open WebUI provide a user-friendly interface for managing your models, making the whole process smoother and more efficient.

By running DeepSeek R1 models locally, you eliminate the need for API calls, third-party logging, and cloud dependencies. Whether you’re testing different models, running benchmarks, or tweaking logic for reinforcement learning, this step-by-step guide will walk you through deploying DeepSeek R1 on your own hardware.

TL;DR: Why this is exciting

• No API limits: Own it without any restrictions.
• No cloud dependency: AI runs entirely on your machine.
• Fast and optimized: Utilize GPU acceleration for peak performance.
• ChatGPT-like UI: Open WebUI transforms your AI into a modern chatbot.
• Expandable: Customize and fine-tune models as needed.

  If you’re looking to bring real AI to your computer, this guide will show you how to do it faster, smarter, and completely under your control.

  Mac mini and DeepSeek are a match made in Heaven
  

  The Mac mini M4 Pro is a powerful machine capable of running AI tasks locally for text, visuals, and advanced reasoning. With its impressive specs, including 64GB of unified memory, a 20-core GPU, and an M4 Pro chip, the Mac mini is well-equipped for handling serious AI workloads. However, the terminal interface leaves much to be desired. That’s where Docker and Open WebUI come into play, transforming your basic terminal into a ChatGPT-like experience with a user-friendly interface and multiple models at your disposal.

  It’s important to note that in this setup, DeepSeek R1 models are run locally using llama.cpp (or Ollama) without relying on any cloud API.

  Running DeepSeek locally: What you need to know
  

  DeepSeek R1 offers a range of text-based models, including a 70B Vision variant for image analysis. Here’s a breakdown of the different model sizes and their requirements:

  | Model | RAM Needed | CPU Required | GPU Needed? | Best Use Case |
  |———-|————–|————————|—————————|————————————|
  | 1.5B | 8GB+ | Any modern CPU | ❌ No | Basic writing, chat, quick responses |
  | 8B | 16GB+ | 4+ Cores | ❌ No | General reasoning, longer writing, coding |
  | 14B | 32GB+ | 6+ Cores | ❌ No | Deeper reasoning, coding, research |
  | 32B | 32-64GB+ | 8+ Cores | ✅ Yes (Metal/CUDA recommended) | Complex problem-solving, AI-assisted coding |
  | 70B | 64GB+ | 12+ Cores | ✅ Yes (High VRAM GPU recommended) | Heavy AI workflows, advanced research |
  | 70B Vision | 64GB+ | 12+ Cores | ✅ Yes (Metal/CUDA recommended) | Image analysis, AI-generated visuals |
  | 1.671B | 512GB+ | 128+ cores (Server-only) | ✅ Must have multiple GPUs | Cloud only — requires enterprise AI servers |

  Ready to set up DeepSeek R1 on your machine? Let’s dive into the process and then explore optimizations to maximize your CPU, GPU, and memory usage.

  The fastest way to get DeepSeek running
  

  If you’re eager to get started right away, follow these steps for a quick setup in the terminal:

  1. Install Ollama (the AI engine): Use the following command to install Ollama and check if it’s installed.

     
     /bin/bash -c "$(curl -fsSL https://ollama.com/download)"<br />
     ollama --version<br />
     ```<br />
     <br />

  2. Download DeepSeek R1 (pick a model size): Choose a model size based on your hardware specifications.

     
     ollama pull deepseek-r1:8b<br />
     ollama pull deepseek-r1:14b<br />
     ollama pull deepseek-r1:32b<br />
     ollama pull deepseek-r1:70b<br />
     ```<br />
     <br />

  3. Run DeepSeek R1 (basic mode): Test the model in the terminal using the following command.

     
     ollama run deepseek-r1:8b<br />
     ```<br />
     <br />
     While this setup works, it lacks the user-friendly interface of a ChatGPT-like experience. Let's enhance the experience by integrating Docker and Open WebUI.<br />
     <br />
     ### Upgrading to a ChatGPT-like interface using Docker and Open WebUI<br />
     <br />
     After installing DeepSeek R1, it's time to move away from the terminal and transition to a web-based chat UI with Docker and Open WebUI. Here's how to do it:<br />
     <br />

  4. Install Docker (required for Open WebUI): Docker will run Open WebUI, providing a modern chat interface.
     Install Docker using the appropriate method.

  5. Install Open WebUI (your local ChatGPT): With Docker installed, run the following command in Terminal to launch Open WebUI.

     
     docker run -d --name open-webui -p 3000:3000 -v open-webui-data:/app/data --pull=always ghcr.io/open-webui/open-webui:main<br />
     ```<br />
     Open Chrome and go to `http://localhost:3000` to start using the ChatGPT-style AI running locally.<br />
     <br />
     By connecting Open WebUI to DeepSeek R1, you can enjoy a ChatGPT-style interface for a more engaging AI experience.<br />
     <br />
     ### Local AI performance variables table<br />
     <br />
     To optimize your local AI setup, consider adjusting the following performance variables to maximize your Mac mini's capabilities:<br />
     <br />
     | Variable          | Command / Env                              | What It Does                                                | Typical Range        | Impact on Speed and Memory                           | Trade-Offs / Notes                                                                                                     |<br />
     |-------------------|--------------------------------------------|-------------------------------------------------------------|----------------------|------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|<br />
     | CPU Threads       | `OLLAMA_THREADS=N` or `--num-threads N`     | Allocates how many CPU threads are used in parallel         | 1 – 256             | Speed: More threads = faster processing, Memory: Slightly increased overhead                                     | Start with a count near your core count and test for optimal performance.                                                 |<br />
     | GPU Layers        | `--n-gpu-layers N`                          | Specifies how many model layers to offload onto the GPU      | 0 – 999             | Speed: Higher layers = more GPU acceleration, Memory: Can exceed VRAM if set too high                              | Experiment with different layer counts for optimal speed and performance.                                                  |<br />
     | Batch Size        | `--batch-size N`                            | Number of tokens processed per iteration                    | 1 – 512 (or more)   | Speed: Larger batch = faster throughput, Memory: Increased RAM or VRAM usage                                       | Adjust batch size based on available resources and performance requirements.                                                |<br />
     | Priority          | `nice -n -20`                               | Raises process priority for AI tasks                        | -20 to 19           | Speed: AI process gets priority CPU time, Memory: No direct impact, only scheduling priority                       | Useful for maximizing CPU resources for AI tasks but may impact performance of other applications.                        |<br />
     | Context Size      | `--context-size N`                          | Sets the model's memory for a single chat context           | 512 – 4096+         | Speed: Larger context = more tokens to process, Memory: Higher context size uses more RAM or VRAM                   | Adjust context size based on the length of chat memory required for optimal performance.                                 |<br />
     | Temperature       | `--temp N`                                  | Controls the creativity of the AI's outputs                  | 0.0 – 2.0           | Speed: No effect on performance, Memory: Purely changes text style                                                   | Experiment with different temperature settings to achieve desired output style.                                             |<br />
     | Multiple Instances| Separate Terminal sessions                  | Runs multiple models concurrently for increased resource usage| 2+ separate runs   | Speed: Combined usage can approach 100% CPU/GPU utilization, Memory: Increased RAM usage                               | Use multiple instances for parallel tasks or model comparisons, but monitor resource usage to prevent memory overload.      |<br />
     <br />
     For more detailed insights and tips on pushing your computer past 20% usage, refer to the performance benchmarks section and monitor your hardware usage using tools like Activity Monitor on macOS and terminal commands like `htop` and `sudo powermetrics`.<br />
     <br />
     ### Performance benchmarks: Real times<br />
     <br />
     To gauge the performance of different DeepSeek R1 models, we conducted benchmarks on tasks like code generation. Here are the approximate times taken by each model for a specific task:<br />
     <br />

• 1.8B: ~3 minutes 40 seconds
• 1.8B (second run, control): ~3 minutes 54 seconds
• 1.14B: ~6 minutes 53 seconds
• 32B: ~7 minutes 10 seconds
• 1.70B: ~13 minutes 81 seconds (approximately 13:48)

  Smaller models tend to run faster, with the 32B model being slightly slower than the 14B model. However, the 70B model offers a good balance between reasoning power and speed. Experiment with different settings to find the optimal configuration for your system.

  Why the 1.671B model didn’t work (and won’t for most people)
  

  Attempting to run the 1.671B model on a Mac mini M4 Pro is impractical due to several reasons:

• It’s too big for your RAM: The model requires more memory than your Mac mini can provide.
• Built for cloud AI: The model is designed for enterprise-grade servers with multiple GPUs.
• Swapping memory won’t help: Using SSD for memory swapping is too slow for AI inference.
• Big tech uses supercomputers: Companies like OpenAI use powerful setups for running models of this scale, beyond the capabilities of personal computers.

  Instead, consider running the 70B model for a more feasible and effective local AI experience.

  Pros and cons of running DeepSeek R1 and Janus locally
  

  Pros:

• No cloud dependency: Own your data without restrictions.
• Faster response times: Eliminate latency with local processing.
• More control and customization: Fine-tune models and experiment with different settings.
• Cheaper in the long run: No recurring fees for API access.
• Supports advanced features: Implement complex AI techniques like chain-of-thought reasoning.

  Cons:

• Limited hardware = Slower performance: Larger models may be sluggish on consumer hardware.
• No built-in memory or chat history: Conversations reset each time without proper configuration.
• No pre-trained APIs for easy deployment: Running DeepSeek R1 locally requires setup and optimization.
• Some guardrails are still active: Certain topics may trigger strict refusals from the model.
• Setup is a pain: Initial installation and optimization may require effort.
  

  What you’ve accomplished
  

  By following this guide, you’ve successfully set up DeepSeek R1 locally, integrated Open WebUI for an improved user interface, optimized performance variables for efficient processing, and explored the potential of running Janus for visual generation.

  What’s next?
  

• Refining your setup: Fine-tune model parameters for better performance.
• Expanding use cases: Integrate LangChain for AI-powered applications.
• Cloud vs. local trade-offs: Understand the limitations of running large models on personal hardware.

  By continuing to experiment and optimize your setup, you can further enhance your local AI experience and explore new possibilities in the world of AI technology.

  FAQs
  

  1. Can I run DeepSeek R1 models on any Mac mini model?
     • While DeepSeek R1 models can run on most Mac mini models, the performance may vary depending on the hardware specifications.
  2. Is it necessary to use Docker and Open WebUI for running DeepSeek R1 locally?
     • Docker and Open WebUI provide a more user-friendly interface for managing DeepSeek R1 models, but they are not mandatory for running the models locally.
  3. What are the advantages of running AI models locally instead of using cloud-based services?
     • Running AI models locally offers greater control, privacy, and customization options compared to cloud-based services. It also eliminates the need for API calls and reduces dependency on external servers.
  4. How can I monitor the hardware usage of my Mac mini when running DeepSeek R1 models?
     • You can use tools like Activity Monitor on macOS or terminal commands like htop to monitor CPU and GPU usage while running DeepSeek R1 models.
  5. What are some tips for optimizing the performance of DeepSeek R1 models on a Mac mini?
     • Experiment with different settings such as CPU threads, GPU layers, batch size, and context size to find the optimal configuration for your system. Additionally, monitor resource usage and adjust settings accordingly to maximize performance.

       By following these FAQs and the detailed guide provided, you can further enhance your local AI setup and explore the full potential of running DeepSeek R1 models on your Mac mini.