DeepSeek R1 lokaal instellen en uitvoeren met Ollama

Leer hoe je DeepSeek-R1 lokaal installeert, instelt en uitvoert met Ollama en bouw een eenvoudige RAG-applicatie.

Bijgewerkt 2 okt 2026 · 12 min lezen

Verken met AI

Waarom DeepSeek-R1 lokaal uitvoeren?

DeepSeek-R1 lokaal draaien geeft je volledige controle over de uitvoering van het model zonder afhankelijkheid van externe servers. Enkele voordelen van DeepSeek-R1 lokaal draaien:

Privacy & veiligheid: Er verlaat geen data je systeem.
Ononderbroken toegang: Voorkom rate limits, downtime of storingen.
Prestaties: Snellere reacties dankzij lokale inferentie, zonder API-latentie.
Aanpasbaarheid: Pas parameters aan, verfijn prompts en integreer het model in lokale applicaties.
Kostenefficiënt: Geen API-kosten door het model lokaal te draaien.
Offline beschikbaar: Werk zonder internetverbinding zodra het model is gedownload.

DeepSeek-R1 lokaal instellen met Ollama

Ollama maakt het eenvoudig om LLM’s lokaal te draaien door modeldownloads, kwantisatie en executie naadloos te verzorgen.

Stap 1: Installeer Ollama

Download en installeer eerst Ollama via de officiële website.

Zodra de download is voltooid, installeer je de Ollama-app zoals je met elke andere applicatie zou doen.

Stap 2: Download en voer DeepSeek-R1 uit

Laten we de setup testen en ons model downloaden. Start de terminal en typ de volgende opdracht.

ollama run deepseek-r1

Ollama biedt een reeks DeepSeek R1-modellen, van 1,5B parameters tot het volledige 671B-parametermodel. Het 671B-model is het oorspronkelijke DeepSeek-R1, terwijl de kleinere modellen gedistilleerde versies zijn op basis van Qwen- en Llama-architecturen. Als je hardware het 671B-model niet aankan, kun je eenvoudig een kleinere versie draaien met de volgende opdracht en de X hieronder vervangen door de gewenste grootte (1.5b, 7b, 8b, 14b, 32b, 70b, 671b):

ollama run deepseek-r1:Xb

Dankzij deze flexibiliteit kun je de mogelijkheden van DeepSeek-R1 benutten zonder een supercomputer te hebben.

Stap 3: DeepSeek-R1 op de achtergrond laten draaien

Om DeepSeek-R1 continu te laten draaien en via een API aan te bieden, start je de Ollama-server:

ollama serve

Hiermee komt het model beschikbaar voor integratie met andere applicaties.

DeepSeek-R1 lokaal gebruiken

Stap 1: Inferentie uitvoeren via CLI

Zodra het model is gedownload, kun je rechtstreeks in de terminal met DeepSeek-R1 communiceren.

Stap 2: DeepSeek-R1 benaderen via API

Om DeepSeek-R1 in applicaties te integreren, gebruik je de Ollama API met curl:

curl http://localhost:11434/api/chat -d '{
  "model": "deepseek-r1",
  "messages": [{ "role": "user", "content": "Solve: 25 * 25" }],
  "stream": false
}'

curl is een commandoregeltool die standaard op Linux aanwezig is en ook werkt op macOS. Je kunt er HTTP-verzoeken rechtstreeks vanuit de terminal mee doen, waardoor het een uitstekende tool is om met API’s te werken.

Stap 3: DeepSeek-R1 benaderen via Python

We kunnen Ollama in elke IDE naar keuze gebruiken. Je installeert het Ollama Python-pakket met de volgende code:

!pip install ollama

Zodra Ollama is geïnstalleerd, gebruik je het volgende script om met het model te communiceren:

import ollama
response = ollama.chat(
    model="deepseek-r1",
    messages=[
        {"role": "user", "content": "Explain Newton's second law of motion"},
    ],
)
print(response["message"]["content"])

De functie ollama.chat() neemt de modelnaam en een gebruikersprompt aan en verwerkt die als een gesprek. Het script haalt vervolgens het antwoord van het model op en print het.

Een lokale Gradio-app draaien voor RAG met DeepSeek-R1

Laten we een eenvoudige demo-app bouwen met Gradio om documenten te bevragen en te analyseren met DeepSeek-R1.

Stap 1: Vereisten

Voordat we beginnen met de implementatie, zorgen we dat we de volgende tools en bibliotheken geïnstalleerd hebben:

Python 3.8+
LangChain: Framework voor het bouwen van applicaties met large language models (LLM’s), waarmee je eenvoudig kunt ophalen, redeneren en tools integreren.
Chromadb: Een hoogwaardige vectordatabase ontworpen voor efficiënte similariteitszoektochten en opslag van embeddings.
Gradio: Voor het maken van een gebruiksvriendelijke webinterface.

Voer de volgende opdrachten uit om de benodigde dependencies te installeren:

!pip install langchain chromadb gradio 
!pip install -U langchain-community

Zodra bovenstaande dependencies zijn geïnstalleerd, voer je deze import-opdrachten uit:

import gradio as gr
from langchain_community.document_loaders import PyMuPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain_community.embeddings import OllamaEmbeddings
import ollama

Stap 2: De geüploade pdf verwerken

Zodra de bibliotheken zijn geïmporteerd, verwerken we de geüploade pdf.

def process_pdf(pdf_bytes):
    if pdf_bytes is None:
        return None, None, None

    loader = PyMuPDFLoader(pdf_bytes)
    data = loader.load()

    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500, chunk_overlap=100
    )
    chunks = text_splitter.split_documents(data)

    embeddings = OllamaEmbeddings(model="deepseek-r1")
    vectorstore = Chroma.from_documents(
        documents=chunks, embedding=embeddings, persist_directory="./chroma_db"
    )
    retriever = vectorstore.as_retriever()

    return text_splitter, vectorstore, retriever

De functie process_pdf:

Laadt en bereidt pdf-inhoud voor op retrieval-gebaseerd beantwoorden.
Controleert of er een pdf is geüpload.
Extraheert tekst met PyMuPDFLoader.
Splitst tekst in stukken met RecursiveCharacterTextSplitter.
Genereert vector-embeddings met OllamaEmbeddings.
Slaat embeddings op in een Chroma-vectordatabase voor efficiënte retrieval.

Stap 3: Opgehaalde documentstukken combineren

Zodra de embeddings zijn opgehaald, moeten we deze samenvoegen. De functie combine_docs() voegt meerdere opgehaalde documentchunks samen tot één string.

def combine_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

Omdat retrieval-modellen relevante fragmenten ophalen in plaats van volledige documenten, zorgt deze functie ervoor dat de geëxtraheerde content leesbaar en netjes opgemaakt blijft voordat deze naar DeepSeek-R1 wordt gestuurd.

Stap 4: DeepSeek-R1 bevragen met Ollama

Nu is onze invoer voor het model klaar. Laten we DeepSeek R1 instellen met Ollama.

import re

def ollama_llm(question, context):
    formatted_prompt = f"Question: {question}\n\nContext: {context}"

    response = ollama.chat(
        model="deepseek-r1",
        messages=[{"role": "user", "content": formatted_prompt}],
    )

    response_content = response["message"]["content"]

    # Remove content between <think> and </think> tags to remove thinking output
    final_answer = re.sub(r"<think>.*?</think>", "", response_content, flags=re.DOTALL).strip()

    return final_answer

De functie ollama_llm() formatteert de vraag van de gebruiker en de opgehaalde documentcontext tot een gestructureerde prompt. Deze geformatteerde invoer wordt vervolgens naar DeepSeek-R1 gestuurd via ollama.chat(), dat de vraag binnen de gegeven context verwerkt en een relevant antwoord retourneert. Als je het antwoord wilt zonder het ‘denk’-script van het model, gebruik dan de functie strip() om het definitieve antwoord terug te geven.

Stap 5: De RAG-pijplijn

Nu we alle benodigde componenten hebben, bouwen we de RAG-pijplijn voor onze demo.

def rag_chain(question, text_splitter, vectorstore, retriever):
    retrieved_docs = retriever.invoke(question)
    formatted_content = combine_docs(retrieved_docs)
    return ollama_llm(question, formatted_content)

De bovenstaande functie doorzoekt eerst de vectordatabase met retriever.invoke(question) en retourneert de meest relevante documentfragmenten. Deze fragmenten worden met de functie combine_docs tot een gestructureerde invoer gevormd en naar ollama_llm gestuurd, zodat DeepSeek-R1 goed onderbouwde antwoorden kan genereren op basis van de opgehaalde inhoud.

Stap 6: De Gradio-interface maken

We hebben onze RAG-pijplijn klaar. Nu bouwen we lokaal de Gradio-interface samen met het DeepSeek-R1-model om een pdf te verwerken en er vragen over te stellen.

def ask_question(pdf_bytes, question):
    text_splitter, vectorstore, retriever = process_pdf(pdf_bytes)

    if text_splitter is None:
        return None  # No PDF uploaded

    result = rag_chain(question, text_splitter, vectorstore, retriever)
    return {result}


interface = gr.Interface(
    fn=ask_question,
    inputs=[
        gr.File(label="Upload PDF (optional)"),
        gr.Textbox(label="Ask a question"),
    ],
    outputs="text",
    title="Ask questions about your PDF",
    description="Use DeepSeek-R1 to answer your questions about the uploaded PDF document.",
)

interface.launch()

We doen het volgende:

Controleren of er een pdf is geüpload.
De pdf verwerken met de functie process_pdf om tekst te extraheren en document-embeddings te genereren.
De vraag van de gebruiker en de document-embeddings doorgeven aan de functie rag_chain() om relevante informatie op te halen en een contextueel correct antwoord te genereren.
Een op Gradio gebaseerde webinterface opzetten waarmee gebruikers een pdf kunnen uploaden en vragen kunnen stellen over de inhoud.
De lay-out definiëren met de functie gr.Interface(), met een pdf-bestand en een tekstvraag als invoer.
De applicatie starten met interface.launch() voor naadloze, interactieve document-gebaseerde Q&A in de browser.

Conclusie

DeepSeek-R1 lokaal draaien met Ollama zorgt voor snellere, private en kostenefficiënte modelinference. Met een eenvoudig installatieproces, CLI-interactie, API-ondersteuning en Python-integratie kun je DeepSeek-R1 inzetten voor uiteenlopende AI-toepassingen, van algemene vragen tot complexe retrieval-taken.

Om op de hoogte te blijven van de laatste ontwikkelingen in AI, raad ik deze blogs aan: