Cara Mengatur dan Menjalankan DeepSeek R1 Secara Lokal dengan Ollama

Mengapa Menjalankan DeepSeek-R1 Secara Lokal?

Menjalankan DeepSeek-R1 secara lokal memberi Anda kendali penuh atas eksekusi model tanpa bergantung pada server eksternal. Berikut beberapa keuntungan menjalankan DeepSeek-R1 secara lokal:

• Privasi & keamanan: Tidak ada data yang keluar dari sistem Anda.
• Akses tanpa gangguan: Hindari batasan kuota, downtime, atau gangguan layanan.
• Kinerja: Dapatkan respons lebih cepat dengan inferensi lokal, tanpa latensi API.
• Kustomisasi: Ubah parameter, fine-tune prompt, dan integrasikan model ke aplikasi lokal.
• Efisiensi biaya: Hilangkan biaya API dengan menjalankan model secara lokal.
• Ketersediaan offline: Bekerja tanpa koneksi internet setelah model diunduh.

Menyiapkan DeepSeek-R1 Secara Lokal dengan Ollama

Ollama mempermudah menjalankan LLM secara lokal dengan menangani pengunduhan model, kuantisasi, dan eksekusi secara mulus.

Langkah 1: Instal Ollama

Pertama, unduh dan instal Ollama dari situs web resmi.

Setelah unduhan selesai, instal aplikasi Ollama seperti Anda menginstal aplikasi lainnya.

Langkah 2: Mengunduh dan menjalankan DeepSeek-R1

Mari uji pengaturan dan unduh model kita. Buka terminal dan ketik perintah berikut.

ollama run deepseek-r1

Ollama menawarkan beragam model DeepSeek R1, mulai dari 1,5B parameter hingga model penuh 671B parameter. Model 671B adalah DeepSeek-R1 asli, sementara model yang lebih kecil merupakan versi distilasi berbasis arsitektur Qwen dan Llama. Jika perangkat keras Anda tidak mendukung model 671B, Anda dapat dengan mudah menjalankan versi yang lebih kecil dengan menggunakan perintah berikut dan mengganti X di bawah ini dengan ukuran parameter yang Anda inginkan (1.5b, 7b, 8b, 14b, 32b, 70b, 671b):

ollama run deepseek-r1:Xb

Dengan fleksibilitas ini, Anda tetap dapat memanfaatkan kemampuan DeepSeek-R1 bahkan tanpa superkomputer.

Langkah 3: Menjalankan DeepSeek-R1 di latar belakang

Untuk menjalankan DeepSeek-R1 secara terus-menerus dan menyajikannya melalui API, jalankan server Ollama:

ollama serve

Ini akan membuat model tersedia untuk diintegrasikan dengan aplikasi lain.

Menggunakan DeepSeek-R1 Secara Lokal

Langkah 1: Menjalankan inferensi melalui CLI

Setelah model diunduh, Anda dapat berinteraksi dengan DeepSeek-R1 langsung di terminal.

Langkah 2: Mengakses DeepSeek-R1 melalui API

Untuk mengintegrasikan DeepSeek-R1 ke aplikasi, gunakan API Ollama dengan curl:

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

curl adalah alat baris perintah yang native di Linux tetapi juga berfungsi di macOS. Alat ini memungkinkan pengguna membuat permintaan HTTP langsung dari terminal, sehingga sangat cocok untuk berinteraksi dengan API.

Langkah 3: Mengakses DeepSeek-R1 melalui Python

Kita dapat menjalankan Ollama di lingkungan pengembangan terintegrasi (IDE) apa pun. Anda dapat memasang paket Python Ollama menggunakan kode berikut:

!pip install ollama

Setelah Ollama terpasang, gunakan skrip berikut untuk berinteraksi dengan model:

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

Fungsi ollama.chat() menerima nama model dan prompt pengguna, lalu memprosesnya sebagai percakapan. Skrip kemudian mengekstrak dan mencetak respons model.

Menjalankan Aplikasi Gradio Lokal untuk RAG dengan DeepSeek-R1

Mari kita bangun aplikasi demo sederhana menggunakan Gradio untuk menanyakan dan menganalisis dokumen dengan DeepSeek-R1.

Langkah 1: Prasyarat

Sebelum masuk ke implementasi, pastikan kita telah memasang alat dan pustaka berikut:

• Python 3.8+
• Langchain: Kerangka kerja untuk membangun aplikasi berbasis large language models (LLM), yang memudahkan pengambilan, penalaran, dan integrasi alat.
• Chromadb: Basis data vektor berkinerja tinggi yang dirancang untuk pencarian kemiripan dan penyimpanan embedding secara efisien.
• Gradio: Untuk membuat antarmuka web yang ramah pengguna.

Jalankan perintah berikut untuk memasang dependensi yang diperlukan:

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

Setelah dependensi di atas terpasang, jalankan perintah impor berikut:

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

Langkah 2: Memproses PDF yang diunggah

Setelah pustaka diimpor, kita akan memproses PDF yang diunggah.

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

Fungsi process_pdf:

• Memuat dan menyiapkan konten PDF untuk penjawaban berbasis penelusuran (retrieval).
• Memeriksa apakah PDF diunggah.
• Menarik teks menggunakan PyMuPDFLoader.
• Membagi teks menjadi potongan menggunakan RecursiveCharacterTextSplitter.
• Menghasilkan embedding vektor menggunakan OllamaEmbeddings.
• Menyimpan embedding di penyimpanan vektor Chroma untuk pengambilan yang efisien.

Langkah 3: Menggabungkan potongan dokumen yang diambil

Setelah embedding diambil, selanjutnya kita perlu menyusunnya kembali. Fungsi combine_docs() menggabungkan beberapa potongan dokumen yang diambil menjadi satu string.

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

Karena model berbasis penelusuran mengambil kutipan yang relevan alih-alih seluruh dokumen, fungsi ini memastikan konten yang diekstrak tetap mudah dibaca dan terformat dengan baik sebelum diteruskan ke DeepSeek-R1.

Langkah 4: Mengajukan pertanyaan ke DeepSeek-R1 menggunakan Ollama

Sekarang, masukan ke model sudah siap. Mari menyiapkan DeepSeek R1 menggunakan 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

Fungsi ollama_llm() memformat pertanyaan pengguna dan konteks dokumen yang diambil menjadi prompt terstruktur. Masukan terformat ini kemudian dikirim ke DeepSeek-R1 melalui ollama.chat(), yang memproses pertanyaan dalam konteks yang diberikan dan mengembalikan jawaban yang relevan. Jika Anda memerlukan jawaban tanpa naskah pemikiran model, gunakan fungsi strip() untuk mengembalikan jawaban akhir.

Langkah 5: Pipeline RAG

Sekarang kita sudah memiliki semua komponen yang diperlukan, mari kita bangun pipeline RAG untuk demo kita.

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)

Fungsi di atas terlebih dahulu mencari di penyimpanan vektor menggunakan retriever.invoke(question), lalu mengembalikan kutipan dokumen yang paling relevan. Kutipan ini diformat menjadi masukan terstruktur menggunakan fungsi combine_docs dan dikirim ke ollama_llm, sehingga DeepSeek-R1 menghasilkan jawaban yang tepat berdasarkan konten yang diambil.

Langkah 6: Membuat Antarmuka Gradio

Kita sudah memiliki pipeline RAG. Sekarang, kita dapat membangun antarmuka Gradio secara lokal bersama model DeepSeek-R1 untuk memproses input PDF dan mengajukan pertanyaan terkait.

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()

Kita melakukan langkah-langkah berikut:

• Memeriksa apakah ada PDF yang diunggah.
• Memproses PDF menggunakan fungsi process_pdf untuk mengekstrak teks dan menghasilkan embedding dokumen.
• Meneruskan kueri pengguna dan embedding dokumen ke fungsi rag_chain() untuk mengambil informasi yang relevan dan menghasilkan respons yang kontekstual.
• Menyiapkan antarmuka web berbasis Gradio agar pengguna dapat mengunggah PDF dan mengajukan pertanyaan tentang isinya.
• Mendefinisikan tata letak menggunakan fungsi gr.Interface(), menerima file PDF dan kueri teks sebagai masukan.
• Menjalankan aplikasi menggunakan interface.launch() untuk menghadirkan tanya jawab berbasis dokumen yang interaktif melalui peramban web.

Kesimpulan

Menjalankan DeepSeek-R1 secara lokal dengan Ollama menghadirkan inferensi model yang lebih cepat, privat, dan hemat biaya. Dengan proses instalasi yang sederhana, interaksi melalui CLI, dukungan API, dan integrasi Python, Anda dapat menggunakan DeepSeek-R1 untuk berbagai aplikasi AI, mulai dari kueri umum hingga tugas berbasis penelusuran yang kompleks.

Untuk mengikuti perkembangan terbaru di bidang AI, saya merekomendasikan blog berikut:

• Qwen 2.5-Max
• Janus-Pro dari DeepSeek
• Proyek Demo DeepSeek-R1 dengan Gradio dan EasyOCR
• Cara Menggunakan DeepSeek Janus-Pro Secara Lokal