Integrasikan DeepSeek API ke dalam Aplikasi Anda Hanya dalam 5 Menit

Di era aplikasi bertenaga AI, mengintegrasikan model bahasa tingkat lanjut ke dalam perangkat lunak Anda dapat membuka kemampuan yang belum pernah terjadi sebelumnya—mulai dari chatbot cerdas hingga alat analisis data. API DeepSeek menawarkan fungsionalitas AI mutakhir, tetapi tantangan sebenarnya terletak pada mengintegrasikannya dengan mulus ke dalam aplikasi Anda tanpa terjebak oleh debugging atau kode boilerplate.

Panduan ini memandu Anda melalui seluruh proses integrasi API DeepSeek ke dalam aplikasi Anda, dengan memanfaatkan platform API intuitif — Apidog untuk menguji, men-debug, dan menghasilkan cuplikan kode siap pakai dalam hitungan menit. Baik Anda sedang membangun backend Python atau frontend JavaScript, pada akhir artikel ini, Anda akan memiliki integrasi API yang berfungsi penuh dengan upaya minimal.

Prasyarat

Akun DeepSeek (daftar di sini).
Pengetahuan dasar tentang API REST dan pemrograman (Python/JavaScript digunakan di sini).
Alat seperti Apidog untuk menguji API.

Langkah 1: Dapatkan Kunci API DeepSeek

Setiap permintaan API memerlukan autentikasi. Berikut cara mendapatkan kunci Anda:

Masuk ke akun DeepSeek Anda.
Buka API Keys di bawah pengaturan akun Anda.
Klik Create new APl key dan salin.

⚠️ Penting: Perlakukan kunci ini seperti kata sandi. Jangan pernah mengungkapkannya dalam kode sisi klien atau repositori publik.

Langkah 2: Uji API DeepSeek

Dokumentasi API DeepSeek yang dibuat oleh Apidog menyediakan arena bermain interaktif untuk menguji titik akhir secara langsung pada dokumentasi tanpa menulis satu baris kode pun. Berikut caranya:

1. Buka Dokumentasi: Buka titik akhir Create Chat Completion.

2. Autentikasi:

Klik Try it out atau Run in Apidog.
Pada panel permintaan pop-out, buka bagian Headers atau Auth, dan tambahkan kunci API Anda:

Authorization: Bearer YOUR_API_KEY

3. Buat Permintaan Anda:

Di badan permintaan, tentukan model (mis., deepseek-chat) dan tambahkan pesan:

{
  "model": "deepseek-chat",
  "messages": [
    {"role": "user", "content": "Explain quantum computing in 3 sentences."}
  ]
}

4. Kirim Permintaan: Klik Send dan lihat respons secara waktu nyata.

Mengapa Ini Penting: Menguji API secara manual membantu Anda memvalidasi struktur payload dan penanganan kesalahan sebelum menulis kode integrasi.

Langkah 3: Hasilkan Cuplikan Kode untuk Tumpukan Anda

Apidog memungkinkan Anda untuk menghasilkan kode bisnis siap pakai untuk berbagai bahasa dan kerangka kerja berdasarkan dokumentasi API yang dapat langsung digunakan di tumpukan Anda. Berikut caranya:

1. Buka proyek DeekSeek di aplikasi Apidog:

Untuk membuka proyek API DeepSeek di aplikasi web Apidog, cukup klik "Run in Apidog" di kanan atas dokumentasi.

Click on "Run in Apidog" to run the project on Apidog app

TIP PRO: Untuk membuka proyek di aplikasi desktop Apidog, klik "Open on desktop" di kanan atas setelah itu.

2. Pilih Bahasa Anda:

Pada halaman dokumentasi API DeepSeek, klik tombol </> Generate Code.

generating code directly from API documentation created by Apidog

Pilih bahasa Anda (mis., Python, JavaScript, Go, dan lainnya).

choose the language to generate the codes

3. Salin-Tempel Kode:

Untuk Python (menggunakan requests):

import requests
import json

url = "https://api.deepseek.com/chat/completions"

payload = json.dumps({
   "messages": [
      {
         "content": "You are a helpful assistant",
         "role": "system"
      },
      {
         "content": "Hi",
         "role": "user"
      }
   ],
   "model": "deepseek-chat",
   "frequency_penalty": 0,
   "max_tokens": 2048,
   "presence_penalty": 0,
   "response_format": {
      "type": "text"
   },
   "stop": None,
   "stream": False,
   "stream_options": None,
   "temperature": 1,
   "top_p": 1,
   "tools": None,
   "tool_choice": "none",
   "logprobs": False,
   "top_logprobs": None
})
headers = {
   'Authorization': 'Bearer {{API_KEY}}',
   'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

Untuk JavaScript (menggunakan fetch):

var myHeaders = new Headers();
myHeaders.append("Authorization", "Bearer {{API_KEY}}");
myHeaders.append("Content-Type", "application/json");

var raw = JSON.stringify({
   "messages": [
      {
         "content": "You are a helpful assistant",
         "role": "system"
      },
      {
         "content": "Hi",
         "role": "user"
      }
   ],
   "model": "deepseek-chat",
   "frequency_penalty": 0,
   "max_tokens": 2048,
   "presence_penalty": 0,
   "response_format": {
      "type": "text"
   },
   "stop": null,
   "stream": false,
   "stream_options": null,
   "temperature": 1,
   "top_p": 1,
   "tools": null,
   "tool_choice": "none",
   "logprobs": false,
   "top_logprobs": null
});

var requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body: raw,
   redirect: 'follow'
};

fetch("https://api.deepseek.com/chat/completions", requestOptions)
   .then(response => response.text())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

4. Sesuaikan Kode: Ganti YOUR_API_KEY dan modifikasi konten pesan.

Langkah 4: Integrasikan ke dalam Aplikasi Anda

Mari kita bangun aplikasi CLI Python sederhana yang menggunakan API DeepSeek untuk menjawab pertanyaan pengguna.

Pengaturan Proyek

1. Buat direktori dan instal dependensi:

mkdir deepseek-cli && cd deepseek-cli  
pip install requests python-dotenv

2. Simpan kunci API Anda dengan aman menggunakan .env:

echo "DEEPSEEK_API_KEY=your_api_key_here" > .env

Implementasi Kode

import argparse
import asyncio
import json
import os
import sys
from typing import AsyncGenerator, Generator

import httpx
import requests


async def async_deepseek(
    api_key: str,
    model: str,
    messages: list,
    temperature: float
) -> AsyncGenerator[str, None]:
    """
    Asynchronous generator for streaming DeepSeek responses
    """
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}",
    }
    data = {
        "model": model,
        "messages": messages,
        "temperature": temperature,
        "stream": True,
    }

    async with httpx.AsyncClient() as client:
        async with client.stream(
            "POST",
            "https://api.deepseek.com/v1/chat/completions",
            headers=headers,
            json=data,
        ) as response:
            response.raise_for_status()
            async for line in response.aiter_lines():
                if line.startswith("data: "):
                    try:
                        json_data = json.loads(line[6:])
                        if chunk := json_data["choices"][0]["delta"].get("content", ""):
                            yield chunk
                    except json.JSONDecodeError:
                        pass


def sync_deepseek(
    api_key: str,
    model: str,
    messages: list,
    temperature: float
) -> Generator[str, None, None]:
    """
    Synchronous generator for streaming DeepSeek responses
    """
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}",
    }
    data = {
        "model": model,
        "messages": messages,
        "temperature": temperature,
        "stream": True,
    }

    with requests.post(
        "https://api.deepseek.com/v1/chat/completions",
        headers=headers,
        json=data,
        stream=True,
    ) as response:
        response.raise_for_status()
        for line in response.iter_lines():
            if line:
                decoded_line = line.decode("utf-8")
                if decoded_line.startswith("data: "):
                    try:
                        json_data = json.loads(decoded_line[6:])
                        if chunk := json_data["choices"][0]["delta"].get("content", ""):
                            yield chunk
                    except json.JSONDecodeError:
                        pass


def main():
    parser = argparse.ArgumentParser(
        description="DeepSeek CLI Client - Chat with DeepSeek models"
    )
    parser.add_argument(
        "prompt",
        type=str,
        help="Your message to send to DeepSeek"
    )
    parser.add_argument(
        "--model",
        type=str,
        default="deepseek-chat",
        help="Model to use (default: deepseek-chat)"
    )
    parser.add_argument(
        "--temperature",
        type=float,
        default=0.7,
        help="Temperature parameter (default: 0.7)"
    )
    parser.add_argument(
        "--async-mode",
        action="store_true",
        help="Use asynchronous mode (requires Python 3.7+)"
    )
    args = parser.parse_args()

    api_key = os.getenv("DEEPSEEK_API_KEY")
    if not api_key:
        print("Error: Set your API key in DEEPSEEK_API_KEY environment variable")
        sys.exit(1)

    messages = [{"role": "user", "content": args.prompt}]

    try:
        if args.async_mode:
            async def run_async():
                try:
                    async for chunk in async_deepseek(
                        api_key=api_key,
                        model=args.model,
                        messages=messages,
                        temperature=args.temperature
                    ):
                        print(chunk, end="", flush=True)
                    print()
                except httpx.HTTPStatusError as e:
                    print(f"\nHTTP error occurred: {e.response.status_code} {e.response.reason_phrase}")
                except Exception as e:
                    print(f"\nAn error occurred: {str(e)}")

            asyncio.run(run_async())
        else:
            try:
                for chunk in sync_deepseek(
                    api_key=api_key,
                    model=args.model,
                    messages=messages,
                    temperature=args.temperature
                ):
                    print(chunk, end="", flush=True)
                print()
            except requests.exceptions.HTTPError as e:
                print(f"\nHTTP error occurred: {e.response.status_code} {e.response.reason_phrase}")
            except Exception as e:
                print(f"\nAn error occurred: {str(e)}")

    except KeyboardInterrupt:
        print("\n\nOperation interrupted by user")
        sys.exit(0)


if __name__ == "__main__":
    main()

Jalankan Aplikasi

Ketik pertanyaan (mis., “Apa ibu kota Prancis?”) dan lihat responsnya!

Langkah 5: Tangani Kesalahan dan Kasus Ujung

API dapat gagal karena batasan laju, kunci tidak valid, atau masalah jaringan. Terapkan penanganan kesalahan yang kuat:

1. Periksa Kode Status HTTP:

401 Unauthorized: Kunci API tidak valid.
429 Too Many Requests: Batas laju terlampaui.
500 Internal Server Error: Masalah sisi server.

2. Mekanisme Coba Lagi:

from time import sleep

def get_deepseek_response(prompt, retries=3):
    # ... existing code ...
    except requests.exceptions.RequestException as e:
        if retries > 0:
            sleep(2)
            return get_deepseek_response(prompt, retries - 1)
        else:
            return f"Error: {str(e)}"

3. Validasi Input:
Pastikan prompt berada dalam batas token dan diformat dengan benar.

Langkah 6: Optimalkan untuk Produksi

Cache Respons: Gunakan Redis atau Memcached untuk menyimpan kueri yang sering.
Pantau Penggunaan: Lacak panggilan API untuk menghindari melebihi kuota.
Pemrosesan Asinkron: Untuk aplikasi dengan throughput tinggi, gunakan pustaka asinkron seperti aiohttp (Python) atau axios (JavaScript).

Kesimpulan

Mengintegrasikan API DeepSeek ke dalam aplikasi Anda tidak harus memakan waktu. Dengan menggunakan dokumentasi interaktif untuk menguji titik akhir, menghasilkan kode, dan men-debug dengan cepat, Anda dapat mengirimkan fitur bertenaga AI dalam hitungan jam—bukan hari.

Contoh di atas hanyalah puncak gunung es. Dengan model DeepSeek, Anda dapat membangun apa saja mulai dari generator konten otomatis hingga tutor AI. Sekarang setelah Anda mendapatkan cetak biru, silakan dan ubah aplikasi Anda menjadi pusat kekuatan AI!