Ketika mendengar istilah Artificial Intelligence atau AI, banyak orang langsung membayangkan ChatGPT, Large Language Model (LLM), atau sistem yang membutuhkan GPU mahal.

Padahal, tidak semua aplikasi yang memahami teks manusia harus menggunakan LLM.

Ada pendekatan yang lebih sederhana, ringan, dan cocok untuk dipelajari menggunakan Java, yaitu Natural Language Processing (NLP).

Dalam tutorial ini, kita akan mengenal Apache OpenNLP dan membuat aplikasi sederhana yang dapat membantu mengelola catatan belanja sehari-hari.

Misalnya, kita mengetik:

Beli susu 2 kotak

Aplikasi akan mengubah kalimat tersebut menjadi data terstruktur:

{
  "aksi": "TAMBAH",
  "barang": "susu",
  "jumlah": 2,
  "satuan": "kotak"
}

Kemudian kita mengetik:

Beli telur 10 butir

Aplikasi akan menambahkan telur ke daftar belanja.

Contoh ini memang sederhana, tetapi prinsipnya juga dapat digunakan untuk membuat sistem pencatatan pengeluaran, pengelolaan tugas, atau pemrosesan pesan otomatis.

Kita akan mempelajari semuanya dari dasar, mulai dari instalasi sampai aplikasi dapat dijalankan.

BAGIAN I — MENGENAL NATURAL LANGUAGE PROCESSING

1. Apa Itu NLP?

Natural Language Processing atau NLP adalah bidang dalam kecerdasan buatan dan ilmu komputer yang mempelajari bagaimana komputer dapat memproses, menganalisis, dan menghasilkan bahasa manusia.

Bahasa manusia berbeda dari bahasa pemrograman.

Dalam Java, kita memberikan instruksi yang memiliki aturan sintaks jelas:

int jumlah = 10;

Komputer dapat memahami instruksi tersebut karena Java memiliki aturan bahasa yang formal.

Namun, manusia biasanya memberikan instruksi seperti:

Tolong catat, saya perlu membeli sepuluh butir telur.

Kalimat tersebut memiliki makna, tetapi komputer perlu melakukan pemrosesan untuk mengubahnya menjadi informasi yang dapat digunakan aplikasi.

Di sinilah NLP berperan.

2. Apa Itu Apache OpenNLP?

Apache OpenNLP adalah library berbasis Java untuk memproses bahasa alami.

OpenNLP menyediakan berbagai kemampuan, seperti:

Sebagian fitur tersebut membutuhkan model statistik yang sudah dilatih.

Namun, dalam tutorial ini kita akan memulai dari tokenization yang dapat digunakan tanpa mengunduh model bahasa.

Kita kemudian menambahkan aturan sederhana menggunakan Java untuk memahami instruksi belanja.

Penting untuk dipahami bahwa OpenNLP tidak otomatis memahami semua bahasa atau maksud pengguna. Hasilnya bergantung pada fitur, model, dan aturan aplikasi yang kita gunakan.

3. Mengapa Belajar OpenNLP?

Ada beberapa alasan OpenNLP menarik untuk dipelajari.

Pertama, dapat digunakan langsung dari Java.

Jika sudah memahami dasar Java, kita tidak perlu mempelajari bahasa pemrograman baru.

Kedua, dapat berjalan secara lokal.

Untuk pemrosesan sederhana, kita tidak perlu memanggil layanan AI melalui internet.

Ketiga, relatif ringan.

Tokenisasi dan pemrosesan berbasis aturan tidak membutuhkan GPU.

Keempat, membantu memahami fondasi NLP.

Sebelum mempelajari embedding, transformer, atau LLM, kita dapat memahami terlebih dahulu bagaimana teks diproses menjadi token dan informasi terstruktur.

BAGIAN II — MENENTUKAN APLIKASI YANG AKAN DIBUAT

4. Studi Kasus: Pengelola Catatan Belanja

Bayangkan kita sedang menyiapkan daftar belanja.

Biasanya, kita menuliskannya secara manual:

Susu 2 kotak
Telur 10 butir
Beras 5 kg
Kopi 1 bungkus

Kita akan membuat program Java yang menerima perintah dalam bahasa Indonesia.

Contohnya:

beli susu 2 kotak
beli telur 10 butir
beli beras 5 kg
lihat belanja
hapus susu

Aplikasi akan melakukan tiga operasi utama:

1. Menambahkan barang.
2. Menampilkan daftar belanja.
3. Menghapus barang.

Untuk memudahkan pembelajaran, aplikasi berjalan melalui terminal atau console.

Kita belum menggunakan Spring Boot, React, atau database.

Setelah konsepnya dipahami, aplikasi ini dapat dikembangkan menjadi REST API atau aplikasi web.

5. Bagaimana Aplikasi Bekerja?

Alur pemrosesannya adalah:

Pengguna mengetik kalimat
          |
          v
     Apache OpenNLP
       Tokenizer
          |
          v
   Daftar token kata
          |
          v
   Parser aturan Java
          |
          v
   Identifikasi aksi
          |
          v
   Ekstraksi informasi
          |
          v
   Pengelolaan daftar
          |
          v
   Hasil ditampilkan

Contoh:

Input:

beli susu 2 kotak

Setelah tokenisasi:

["beli", "susu", "2", "kotak"]

Parser Java kemudian mengenali:

Aksi   : TAMBAH
Barang : susu
Jumlah : 2
Satuan : kotak

Perlu diperhatikan bahwa OpenNLP bertugas memecah teks menjadi token. Pengenalan aksi, barang, jumlah, dan satuan pada contoh ini dilakukan menggunakan aturan Java yang kita buat sendiri.

BAGIAN III — INSTALASI DAN PERSIAPAN

6. Software yang Dibutuhkan

Untuk mengikuti tutorial ini, siapkan:

Jika JDK 21 dan IntelliJ sudah terpasang dari tutorial Spring Boot sebelumnya, kita dapat langsung melanjutkan.

Instalasi Java

Download JDK 21 dari:

https://adoptium.net/

Setelah instalasi, jalankan:

java -version

Pastikan versi Java muncul.

Instalasi IntelliJ IDEA

Download dari:

https://www.jetbrains.com/idea/

Gunakan IntelliJ IDEA dengan dukungan project Maven.

BAGIAN IV — MEMBUAT PROJECT JAVA

7. Membuat Project Baru di IntelliJ

Buka IntelliJ IDEA.

Pilih:

New Project

Gunakan konfigurasi:

Name         : belajar-opennlp
Language     : Java
Build System : Maven
JDK          : 21

Klik Create.

Tunggu sampai IntelliJ selesai menyiapkan project.

Struktur awal project Maven kurang lebih:

belajar-opennlp/
├── src/
│   ├── main/
│   │   └── java/
│   └── test/
│       └── java/
└── pom.xml

8. Menambahkan Apache OpenNLP

Buka file:

pom.xml

Tambahkan dependency Apache OpenNLP.

Contoh berikut menggunakan OpenNLP 2.5.5. Jika menggunakan versi lain, pastikan API yang digunakan masih kompatibel.

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.nirantara</groupId>
    <artifactId>belajar-opennlp</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.release>21</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.opennlp</groupId>
            <artifactId>opennlp-tools</artifactId>
            <version>2.5.5</version>
        </dependency>
    </dependencies>

</project>

Setelah menyimpan file, klik Load Maven Changes jika IntelliJ menampilkannya.

Maven akan mengunduh library OpenNLP.

Jika dependency belum terbaca, buka panel Maven di IntelliJ kemudian pilih Reload All Maven Projects.

BAGIAN V — PROGRAM OPENNLP PERTAMA

9. Membuat Program Tokenization

Pada folder:

src/main/java

Buat package:

com.nirantara.opennlp

Kemudian buat class:

TokenizerExample.java

Isi dengan:

package com.nirantara.opennlp;

import opennlp.tools.tokenize.SimpleTokenizer;

import java.util.Arrays;

public class TokenizerExample {

    public static void main(String[] args) {

        String kalimat = "Beli susu 2 kotak";

        SimpleTokenizer tokenizer =
                SimpleTokenizer.INSTANCE;

        String[] tokens = tokenizer.tokenize(kalimat);

        System.out.println(Arrays.toString(tokens));
    }
}

Jalankan program melalui tombol Run pada IntelliJ.

Hasil yang diharapkan:

[Beli, susu, 2, kotak]

Selamat, kita sudah menggunakan Apache OpenNLP untuk memproses teks!

10. Memahami Kode Tokenization

Perhatikan:

SimpleTokenizer tokenizer =
        SimpleTokenizer.INSTANCE;

Kita menggunakan tokenizer sederhana yang disediakan OpenNLP.

Kemudian:

String[] tokens = tokenizer.tokenize(kalimat);

Method tokenize() memecah teks menjadi array token.

Misalnya:

Beli susu 2 kotak

Menjadi:

String[] tokens = {
    "Beli",
    "susu",
    "2",
    "kotak"
};

Tokenisasi merupakan salah satu tahap awal yang sering digunakan dalam pemrosesan bahasa alami.

Namun, tokenisasi saja belum cukup untuk memahami maksud sebuah kalimat.

Karena itu, kita akan menambahkan logika pemrosesan sendiri.

BAGIAN VI — MEMBUAT MODEL DATA BELANJA

11. Membuat Class BarangBelanja

Buat class:

BarangBelanja.java

Isi:

package com.nirantara.opennlp;

public class BarangBelanja {

    private String nama;
    private int jumlah;
    private String satuan;

    public BarangBelanja(
            String nama,
            int jumlah,
            String satuan) {

        this.nama = nama;
        this.jumlah = jumlah;
        this.satuan = satuan;
    }

    public String getNama() {
        return nama;
    }

    public int getJumlah() {
        return jumlah;
    }

    public String getSatuan() {
        return satuan;
    }

    @Override
    public String toString() {
        return nama + " - " + jumlah + " " + satuan;
    }
}

Class ini digunakan untuk merepresentasikan satu barang dalam daftar belanja.

Contohnya:

BarangBelanja barang =
        new BarangBelanja("susu", 2, "kotak");

Jika dicetak:

System.out.println(barang);

Hasilnya:

susu - 2 kotak

BAGIAN VII — MEMBUAT PEMROSES PERINTAH

12. Membuat Class BelanjaParser

Sekarang kita akan membuat class yang memproses instruksi pengguna.

Buat:

BelanjaParser.java

Isi:

package com.nirantara.opennlp;

import opennlp.tools.tokenize.SimpleTokenizer;

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Set;

public class BelanjaParser {

    private final SimpleTokenizer tokenizer =
            SimpleTokenizer.INSTANCE;

    private static final Set<String> SATUAN = Set.of(
            "kg", "gram", "liter", "ml",
            "kotak", "butir", "bungkus",
            "botol", "buah", "pak"
    );

    public Perintah parse(String input) {

        if (input == null || input.isBlank()) {
            return Perintah.tidakDikenal();
        }

        String normalized = input
                .toLowerCase(Locale.ROOT)
                .trim();

        String[] tokens = tokenizer.tokenize(normalized);

        if (tokens.length == 0) {
            return Perintah.tidakDikenal();
        }

        String aksi = tokens[0];

        if (aksi.equals("lihat")
                && tokens.length == 2
                && tokens[1].equals("belanja")) {

            return new Perintah(
                    "LIHAT", null, 0, null
            );
        }

        if (aksi.equals("hapus")
                && tokens.length >= 2) {

            String nama = gabungkan(tokens, 1, tokens.length);

            return new Perintah(
                    "HAPUS", nama, 0, null
            );
        }

        if (!aksi.equals("beli")) {
            return Perintah.tidakDikenal();
        }

        if (tokens.length < 3) {
            return Perintah.tidakDikenal();
        }

        int posisiJumlah = -1;

        for (int i = 1; i < tokens.length; i++) {
            if (tokens[i].matches("\\d+")) {
                posisiJumlah = i;
                break;
            }
        }

        if (posisiJumlah <= 1) {
            return Perintah.tidakDikenal();
        }

        if (posisiJumlah >= tokens.length - 1) {
            return Perintah.tidakDikenal();
        }

        if (posisiJumlah != tokens.length - 2) {
            return Perintah.tidakDikenal();
        }

        String satuan = tokens[tokens.length - 1];

        if (!SATUAN.contains(satuan)) {
            return Perintah.tidakDikenal();
        }

        String nama = gabungkan(
                tokens, 1, posisiJumlah
        );

        try {
            int jumlah = Integer.parseInt(
                    tokens[posisiJumlah]
            );

            if (jumlah <= 0) {
                return Perintah.tidakDikenal();
            }

            return new Perintah(
                    "TAMBAH",
                    nama,
                    jumlah,
                    satuan
            );

        } catch (NumberFormatException e) {
            return Perintah.tidakDikenal();
        }
    }

    private String gabungkan(
            String[] tokens,
            int awal,
            int akhir) {

        List<String> kata = new ArrayList<>();

        for (int i = awal; i < akhir; i++) {
            kata.add(tokens[i]);
        }

        return String.join(" ", kata);
    }
}

Apa yang Dilakukan Parser Ini?

Parser menerima teks:

beli susu 2 kotak

Kemudian:

1. Mengubah teks menjadi huruf kecil.
2. Memecah teks menjadi token menggunakan OpenNLP.
3. Membaca kata pertama untuk menentukan aksi.
4. Mencari angka sebagai jumlah.
5. Memeriksa satuan.
6. Menggabungkan token nama barang.
7. Menghasilkan object perintah.

Contoh:

beli beras merah 5 kg

Akan menghasilkan:

Aksi   : TAMBAH
Barang : beras merah
Jumlah : 5
Satuan : kg

Parser ini sengaja dibatasi pada pola tertentu agar mudah dipahami dan hasilnya dapat diprediksi.

Misalnya, kalimat "tolong belikan saya susu dua kotak" belum dapat diproses dengan benar.

Ini bukan keterbatasan tokenisasi OpenNLP semata, melainkan karena aturan parser yang kita buat masih sederhana.

13. Membuat Class Perintah

Buat:

Perintah.java

Isi:

package com.nirantara.opennlp;

public class Perintah {

    private final String aksi;
    private final String barang;
    private final int jumlah;
    private final String satuan;

    public Perintah(
            String aksi,
            String barang,
            int jumlah,
            String satuan) {

        this.aksi = aksi;
        this.barang = barang;
        this.jumlah = jumlah;
        this.satuan = satuan;
    }

    public static Perintah tidakDikenal() {
        return new Perintah(
                "TIDAK_DIKENAL",
                null,
                0,
                null
        );
    }

    public String getAksi() {
        return aksi;
    }

    public String getBarang() {
        return barang;
    }

    public int getJumlah() {
        return jumlah;
    }

    public String getSatuan() {
        return satuan;
    }
}

Class Perintah berfungsi menyimpan hasil interpretasi parser.

Dengan memisahkan parser dan hasilnya, kode aplikasi menjadi lebih mudah dikembangkan.

BAGIAN VIII — MEMBUAT APLIKASI BELANJA

14. Membuat Class Main

Buat class:

Main.java

Isi:

package com.nirantara.opennlp;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

public class Main {

    private static final List<BarangBelanja> daftar =
            new ArrayList<>();

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        BelanjaParser parser = new BelanjaParser();

        System.out.println("=== CATATAN BELANJA ===");
        System.out.println("Perintah yang tersedia:");
        System.out.println("beli susu 2 kotak");
        System.out.println("lihat belanja");
        System.out.println("hapus susu");
        System.out.println("keluar");

        while (true) {

            System.out.print("\nPerintah: ");

            String input = scanner.nextLine().trim();

            if (input.equalsIgnoreCase("keluar")) {
                System.out.println("Sampai jumpa!");
                break;
            }

            Perintah perintah = parser.parse(input);

            switch (perintah.getAksi()) {

                case "TAMBAH":
                    tambahBarang(perintah);
                    break;

                case "LIHAT":
                    lihatBelanja();
                    break;

                case "HAPUS":
                    hapusBarang(perintah.getBarang());
                    break;

                default:
                    System.out.println(
                        "Perintah tidak dikenali."
                    );
            }
        }

        scanner.close();
    }

    private static void tambahBarang(Perintah perintah) {

        BarangBelanja barang = new BarangBelanja(
                perintah.getBarang(),
                perintah.getJumlah(),
                perintah.getSatuan()
        );

        daftar.add(barang);

        System.out.println(
                "Berhasil menambahkan: " + barang
        );
    }

    private static void lihatBelanja() {

        if (daftar.isEmpty()) {
            System.out.println(
                    "Daftar belanja masih kosong."
            );
            return;
        }

        System.out.println("\nDAFTAR BELANJA:");

        int nomor = 1;

        for (BarangBelanja barang : daftar) {
            System.out.println(
                    nomor++ + ". " + barang
            );
        }
    }

    private static void hapusBarang(String nama) {

        Iterator<BarangBelanja> iterator =
                daftar.iterator();

        boolean ditemukan = false;

        while (iterator.hasNext()) {

            BarangBelanja barang = iterator.next();

            if (barang.getNama().equalsIgnoreCase(nama)) {
                iterator.remove();
                ditemukan = true;
            }
        }

        if (ditemukan) {
            System.out.println(
                    "Barang berhasil dihapus: " + nama
            );
        } else {
            System.out.println(
                    "Barang tidak ditemukan: " + nama
            );
        }
    }
}

15. Menjalankan Aplikasi

Buka Main.java.

Klik tombol Run di IntelliJ.

Terminal akan menampilkan:

=== CATATAN BELANJA ===

Perintah yang tersedia:
beli susu 2 kotak
lihat belanja
hapus susu
keluar

Perintah:

Masukkan:

beli susu 2 kotak

Hasil:

Berhasil menambahkan: susu - 2 kotak

Masukkan:

beli telur 10 butir

Hasil:

Berhasil menambahkan: telur - 10 butir

Masukkan:

beli beras merah 5 kg

Hasil:

Berhasil menambahkan: beras merah - 5 kg

Kemudian:

lihat belanja

Hasil:

DAFTAR BELANJA:
1. susu - 2 kotak
2. telur - 10 butir
3. beras merah - 5 kg

Untuk menghapus:

hapus susu

Hasil:

Barang berhasil dihapus: susu

Aplikasi sekarang sudah dapat menerima instruksi sederhana dan mengelola daftar belanja.

Catatan: Data disimpan dalam ArrayList, sehingga akan hilang ketika program ditutup. Pada pengembangan berikutnya, kita dapat menyimpannya ke file atau database.

BAGIAN IX — MEMAHAMI BATASAN APLIKASI

16. Apakah Ini Sudah Termasuk AI?

Pertanyaan ini penting.

Dalam aplikasi yang baru dibuat, kita menggunakan dua pendekatan:

Apache OpenNLP

Digunakan untuk melakukan tokenisasi teks.

Rule-Based Processing

Digunakan untuk mengenali perintah, jumlah, nama barang, dan satuan.

Dengan demikian, aplikasi ini lebih tepat disebut aplikasi pemrosesan bahasa alami berbasis tokenisasi dan aturan.

Kita belum melatih model Machine Learning untuk mengenali intent.

OpenNLP memang memiliki kemampuan Machine Learning, tetapi kita belum menggunakannya pada tahap ini.

Pendekatan berbasis aturan tetap bermanfaat, terutama jika pola perintah terbatas dan dapat didefinisikan secara jelas.

17. Apa Kelemahan Rule-Based NLP?

Misalnya aplikasi memahami:

beli susu 2 kotak

Tetapi pengguna mengetik:

tolong tambahkan dua kotak susu ke daftar belanja

Maknanya hampir sama, tetapi struktur kalimatnya berbeda.

Parser sederhana kita tidak mengenalinya.

Mengapa?

Karena kita membuat aturan yang mengharuskan:

1. Kata pertama adalah beli.
2. Nama barang berada sebelum jumlah.
3. Jumlah ditulis menggunakan angka.
4. Satuan berada pada akhir kalimat.

Untuk memahami variasi bahasa yang lebih luas, kita membutuhkan pendekatan yang lebih fleksibel.

Salah satunya adalah menggunakan model klasifikasi teks.

BAGIAN X — MENGENAL MACHINE LEARNING DI OPENNLP

18. Apa Itu Intent Classification?

Intent adalah maksud dari sebuah kalimat.

Contoh:

Daripada memeriksa setiap kalimat menggunakan if-else, kita dapat melatih model untuk mengenali pola berdasarkan contoh.

OpenNLP menyediakan kemampuan Document Categorization yang dapat digunakan sebagai dasar klasifikasi intent.

Namun, model perlu dilatih menggunakan dataset yang sesuai.

19. Contoh Format Dataset Training

Kita dapat membuat file teks berisi label dan contoh kalimat.

Misalnya:

TAMBAH beli susu
TAMBAH tambahkan telur
TAMBAH masukkan kopi
TAMBAH catat beras
TAMBAH saya mau beli gula

LIHAT lihat belanja
LIHAT tampilkan daftar
LIHAT apa saja belanjaan
LIHAT cek daftar belanja
LIHAT tunjukkan belanjaan

HAPUS hapus susu
HAPUS buang telur
HAPUS hilangkan kopi
HAPUS coret beras
HAPUS keluarkan gula

Ini hanya contoh untuk menjelaskan format, bukan dataset yang cukup untuk menghasilkan model yang andal.

Untuk aplikasi nyata, kita memerlukan lebih banyak contoh dengan variasi kalimat, ejaan, dan pola bahasa.

Dataset juga perlu dibagi menjadi data training dan data testing agar kita dapat mengukur kemampuan model pada kalimat yang belum pernah dilihat.

20. Apakah Intent Classification Sudah Cukup?

Belum tentu.

Misalnya model berhasil memprediksi:

Intent: TAMBAH

Dari kalimat:

tolong tambahkan dua kotak susu

Kita masih perlu menemukan:

Barang : susu
Jumlah : 2
Satuan : kotak

Proses ini disebut ekstraksi informasi atau slot filling.

Kita dapat menggabungkan beberapa pendekatan:

• Klasifikasi intent untuk menentukan maksud.
• Ekstraksi entitas untuk mengenali informasi penting.
• Normalisasi teks untuk mengubah "dua" menjadi 2.
• Aturan bisnis untuk memvalidasi hasil.

Tidak semua masalah harus diselesaikan dengan satu model.

BAGIAN XI — PENERAPAN OPENNLP DALAM KEHIDUPAN SEHARI-HARI

21. Pencatatan Pengeluaran

Bayangkan kita mengetik:

Bayar parkir 5000

Aplikasi dapat diarahkan untuk menghasilkan:

{
  "kategori": "TRANSPORTASI",
  "deskripsi": "parkir",
  "nominal": 5000
}

Contoh lain:

Beli kopi 25000

Hasil:

{
  "kategori": "MAKAN_MINUM",
  "deskripsi": "kopi",
  "nominal": 25000
}

Data tersebut kemudian dapat disimpan ke database dan digunakan untuk membuat laporan pengeluaran bulanan.

Untuk membuatnya, kita perlu menambahkan aturan atau model yang mengenali nominal dan kategori pengeluaran.

22. Pengelola Tugas Harian

Contoh instruksi:

Ingatkan saya meeting besok jam 10

Aplikasi dapat dirancang untuk mengekstraksi:

{
  "aktivitas": "meeting",
  "tanggal": "besok",
  "waktu": "10:00"
}

Namun, kata "besok" harus dikonversi menjadi tanggal berdasarkan waktu saat instruksi diterima.

Selain itu, untuk benar-benar mengirim pengingat, aplikasi membutuhkan mekanisme penjadwalan. OpenNLP sendiri tidak menyediakan layanan pengingat.

23. Mengelompokkan Pesan Masuk

Misalnya kita memiliki ratusan pesan:

Saya tidak bisa login.
Pembayaran saya gagal.
Bagaimana cara mengganti password?
Aplikasi tidak bisa dibuka.

Dengan dataset training yang sesuai, kita dapat mengembangkan sistem klasifikasi:

LOGIN
PEMBAYARAN
PASSWORD
GANGGUAN_APLIKASI

Pendekatan ini dapat membantu mengelompokkan pesan customer service sebelum diteruskan kepada petugas yang sesuai.

24. Mengelompokkan Catatan Pribadi

Misalnya kita memiliki catatan:

Servis motor hari Sabtu.
Bayar listrik tanggal 20.
Beli beras minggu depan.
Meeting dengan tim besok.

Aplikasi dapat dirancang untuk mengelompokkan catatan menjadi:

KENDARAAN
TAGIHAN
BELANJA
PEKERJAAN

Pengelompokan tersebut dapat menggunakan aturan sederhana atau model klasifikasi yang dilatih dari contoh.

BAGIAN XII — OPENNLP VS REGEX VS LLM

25. Kapan Sebaiknya Menggunakan OpenNLP?

Tidak semua aplikasi membutuhkan LLM.

Sebaliknya, tidak semua kebutuhan pemahaman bahasa dapat diselesaikan menggunakan regex.

Berikut perbandingan sederhananya:

Untuk aplikasi catatan belanja dengan pola perintah terbatas, regex dan aturan Java mungkin sudah cukup.

Jika aplikasi harus mengenali berbagai variasi kalimat berdasarkan dataset, model klasifikasi dapat menjadi pilihan.

Jika aplikasi harus memahami instruksi kompleks dan konteks percakapan yang panjang, LLM mungkin lebih sesuai.

Pemilihan teknologi sebaiknya berdasarkan kebutuhan, bukan sekadar tren.

BAGIAN XIII — PENGEMBANGAN SELANJUTNYA

26. Menambahkan Penyimpanan Database

Saat ini daftar belanja menggunakan:

List<BarangBelanja> daftar = new ArrayList<>();

Artinya, data hanya tersimpan selama aplikasi berjalan.

Untuk menyimpan data secara permanen, kita dapat menggunakan:

• H2.
• SQLite.
• PostgreSQL.
• MySQL.

Jika sudah mempelajari Spring Boot, kita dapat menggunakan Spring Data JPA untuk mengelola penyimpanan.

27. Mengubah Aplikasi Menjadi REST API

Aplikasi console dapat dikembangkan menjadi layanan backend.

Contohnya:

POST /api/belanja/parse

Request:

{
  "text": "beli susu 2 kotak"
}

Response:

{
  "aksi": "TAMBAH",
  "barang": "susu",
  "jumlah": 2,
  "satuan": "kotak"
}

Dengan pendekatan ini, frontend React dapat mengirim instruksi bahasa Indonesia ke Spring Boot.

Backend kemudian menggunakan OpenNLP dan parser untuk mengolah teks.

28. Menggabungkan OpenNLP dengan Spring Boot dan React

Arsitektur sederhana yang dapat dikembangkan:

React JS
   |
   | HTTP Request
   v
Spring Boot Controller
   |
   v
NLP Service
   |
   +-- OpenNLP Tokenizer
   |
   +-- Intent Classifier
   |
   +-- Entity Extraction
   |
   +-- Business Rules
   |
   v
Spring Data JPA
   |
   v
Database

Dengan arsitektur ini, aplikasi tidak hanya menerima input melalui form biasa, tetapi juga dapat menerima instruksi dalam bahasa alami.

Misalnya:

Tambahkan kopi 2 bungkus.

React mengirim teks tersebut ke backend, kemudian backend mengolahnya menjadi data yang siap disimpan.

BAGIAN XIV — TROUBLESHOOTING

29. Dependency OpenNLP Tidak Ditemukan

Jika IntelliJ menampilkan:

Cannot resolve symbol 'opennlp'

Periksa dependency dalam pom.xml.

Kemudian lakukan Maven Reload.

Pastikan komputer memiliki koneksi internet ketika Maven pertama kali mengunduh dependency.

30. Class Main Tidak Bisa Dijalankan

Periksa apakah class memiliki:

public static void main(String[] args)

Pastikan file berada di folder:

src/main/java

Dan deklarasi package sesuai dengan struktur folder.

31. Perintah Tidak Dikenali

Jika aplikasi menampilkan:

Perintah tidak dikenali.

Periksa pola kalimat yang dimasukkan.

Parser tutorial ini hanya mendukung pola utama:

beli [nama barang] [jumlah angka] [satuan]
lihat belanja
hapus [nama barang]

Contoh yang valid:

beli gula pasir 2 kg

Contoh yang belum didukung:

tolong belikan gula pasir dua kilogram

Untuk mendukung variasi tersebut, kita perlu mengembangkan normalisasi, parser, atau model NLP.

32. Data Hilang Setelah Program Ditutup

Ini merupakan perilaku yang diharapkan karena kita menggunakan ArrayList.

Data belum disimpan ke database atau file.

Jika ingin mempertahankan data setelah aplikasi ditutup, tambahkan mekanisme penyimpanan permanen.

Kesimpulan

Apache OpenNLP merupakan salah satu library yang dapat digunakan untuk mempelajari pemrosesan bahasa alami menggunakan Java.

Melalui tutorial ini, kita telah mempelajari bagaimana sebuah kalimat dapat dipecah menjadi token, dianalisis menggunakan aturan, dan diubah menjadi data yang dapat digunakan oleh aplikasi.

Kita juga memahami bahwa tokenisasi, klasifikasi intent, dan ekstraksi informasi merupakan proses yang berbeda.

OpenNLP tidak otomatis membuat komputer memahami semua instruksi manusia. Kemampuan aplikasi sangat bergantung pada model, dataset, aturan, dan desain sistem yang digunakan.

Untuk kebutuhan sederhana, pendekatan berbasis aturan sering kali sudah memadai. Untuk variasi bahasa yang lebih kompleks, kita dapat menambahkan model Machine Learning atau pendekatan NLP lainnya.

Yang terpenting, kita tidak harus langsung menggunakan LLM untuk mulai membangun aplikasi yang memproses bahasa manusia.

Memahami NLP dari dasar membantu kita memilih teknologi yang tepat, bukan sekadar teknologi yang paling populer.

Referensi

• Apache OpenNLP — https://opennlp.apache.org/
• Apache OpenNLP GitHub — https://github.com/apache/opennlp
• Apache Maven — https://maven.apache.org/
• Java Documentation — https://dev.java/
• IntelliJ IDEA — https://www.jetbrains.com/idea/
• Spring Boot — https://spring.io/projects/spring-boot

Artikel Nirantara — Membangun Software, Mengeksplorasi AI.