Membuat Agen AI yang Kuat dengan Function Calling, Ollama, Granite, dan Terraform

Di era kecerdasan buatan yang berkembang pesat, agen AI semakin banyak digunakan untuk mengotomatiskan tugas, meningkatkan efisiensi, dan memberikan solusi inovatif. Salah satu teknik paling menarik untuk meningkatkan kemampuan agen AI adalah Function Calling, yang memungkinkan model bahasa besar (LLM) untuk berinteraksi dengan alat dan API eksternal. Dalam postingan blog ini, kita akan menjelajahi cara membangun agen AI yang kuat menggunakan Function Calling, memanfaatkan kekuatan Ollama untuk menjalankan model lokal, Granite sebagai LLM pilihan, dan Terraform untuk orkestrasi infrastruktur.

Daftar Isi

1. Pendahuluan: Mengapa Function Calling Itu Penting untuk Agen AI?
2. Memahami Komponen: Ollama, Granite, dan Terraform
   • Ollama: Menjalankan Model Bahasa Secara Lokal
   • Granite: Model Bahasa yang Kuat
   • Terraform: Infrastruktur sebagai Kode
3. Arsitektur Agen AI: Gambaran Umum
4. Langkah-Langkah Implementasi: Panduan Langkah demi Langkah
   • Menyiapkan Ollama
   • Mengunduh dan Menjalankan Model Granite
   • Membuat Definisi Fungsi
   • Mengimplementasikan Logika Agen AI dengan Function Calling
   • Menggunakan Terraform untuk Penyediaan Infrastruktur
5. Contoh Kasus: Agen AI untuk Otomatisasi Tugas
   • Contoh 1: Agen Penjadwalan Rapat
   • Contoh 2: Agen Pencarian Informasi
   • Contoh 3: Agen Analisis Sentimen
6. Optimasi dan Tuning
   • Prompt Engineering
   • Fine-tuning Model
   • Pemantauan dan Log
7. Keamanan dan Pertimbangan
8. Tantangan Umum dan Pemecahan Masalah
9. Kesimpulan: Masa Depan Agen AI dengan Function Calling
10. Sumber Daya Tambahan

1. Pendahuluan: Mengapa Function Calling Itu Penting untuk Agen AI?

Agen AI, di inti mereka, adalah sistem yang dirancang untuk merasakan lingkungan mereka, memproses informasi, dan mengambil tindakan untuk mencapai tujuan tertentu. Tradisionalnya, agen AI bergantung pada kemampuan bawaan mereka sendiri, yang seringkali terbatas. Function Calling mengubah paradigma ini dengan memungkinkan agen AI untuk mengakses dan menggunakan alat dan API eksternal. Ini membuka kemungkinan baru:

• Kemampuan yang Diperluas: Agen AI dapat melakukan tugas di luar kemampuan bawaan mereka, seperti melakukan pencarian web, mengirim email, mengakses database, dan banyak lagi.
• Fleksibilitas yang Ditingkatkan: Agen AI dapat beradaptasi dengan berbagai lingkungan dan skenario dengan secara dinamis memanggil fungsi yang berbeda sesuai kebutuhan.
• Otomatisasi yang Lebih Baik: Agen AI dapat mengotomatiskan alur kerja yang kompleks dengan mengikat tugas yang berbeda bersama-sama melalui Function Calling.
• Pemahaman yang Lebih Mendalam: Function Calling memungkinkan LLM untuk mendapatkan informasi konkret dari lingkungan, yang dapat meningkatkan pemahaman dan pengambilan keputusan secara signifikan.

Singkatnya, Function Calling memberdayakan agen AI untuk menjadi lebih cerdas, lebih serbaguna, dan lebih berguna dalam berbagai aplikasi.

2. Memahami Komponen: Ollama, Granite, dan Terraform

Sebelum kita menyelami implementasi, mari kita pahami peran masing-masing komponen kunci dalam arsitektur kita:

Ollama: Menjalankan Model Bahasa Secara Lokal

Ollama adalah alat yang kuat dan mudah digunakan yang memungkinkan Anda untuk menjalankan model bahasa besar (LLM) secara lokal di mesin Anda. Ini menyederhanakan proses mengunduh, menyiapkan, dan mengelola model, membuatnya dapat diakses oleh pengembang dari semua tingkat keahlian. Fitur utama Ollama meliputi:

• Instalasi Sederhana: Ollama menyediakan proses instalasi yang mudah, membuatnya mudah untuk memulai.
• Dukungan Model: Ollama mendukung berbagai model bahasa populer, memungkinkan Anda untuk memilih yang paling sesuai dengan kebutuhan Anda.
• Manajemen Model: Ollama menyederhanakan manajemen model dengan memungkinkan Anda untuk mengunduh, memperbarui, dan menghapus model dengan mudah.
• API Sederhana: Ollama menyediakan API RESTful sederhana yang memungkinkan Anda untuk berinteraksi dengan model dari aplikasi Anda.
• Berjalan Offline: Karena model berjalan secara lokal, tidak diperlukan koneksi internet setelah model diunduh.

Ollama sangat ideal untuk pengembang yang ingin bereksperimen dengan LLM, membangun aplikasi offline, atau membutuhkan kontrol dan privasi yang lebih besar atas model mereka.

Granite: Model Bahasa yang Kuat

Granite adalah keluarga model bahasa besar (LLM) yang dikembangkan oleh IBM. Mereka dikenal karena kinerja, efisiensi, dan kemampuan mereka untuk menangani berbagai tugas pemrosesan bahasa alami (NLP). Granite menawarkan keseimbangan antara akurasi dan kecepatan inferensi, menjadikannya pilihan yang baik untuk agen AI yang membutuhkan respons yang cepat dan andal. Keuntungan utama menggunakan Granite meliputi:

• Kinerja Tinggi: Granite mencapai hasil yang kompetitif pada berbagai benchmark NLP.
• Efisiensi: Granite dirancang untuk berjalan secara efisien pada berbagai perangkat keras, termasuk CPU dan GPU.
• Fleksibilitas: Granite tersedia dalam berbagai ukuran, memungkinkan Anda untuk memilih model yang paling sesuai dengan sumber daya dan kebutuhan Anda.
• Function Calling: Model Granite dilatih secara khusus untuk bekerja dengan Function Calling, menjadikannya sangat cocok untuk membangun agen AI.

Untuk panduan tentang cara menggunakan model IBM Granite dengan Function Calling, lihat artikel resmi IBM. Artikel ini menjelaskan kemampuan Function Calling dari model IBM Granite dan bagaimana mereka membedakannya.

Terraform: Infrastruktur sebagai Kode

Terraform adalah alat Infrastruktur sebagai Kode (IaC) yang memungkinkan Anda untuk mendefinisikan dan menyediakan infrastruktur menggunakan file konfigurasi. Dengan Terraform, Anda dapat mengotomatiskan proses pembuatan dan pengelolaan sumber daya, memastikan konsistensi dan mengurangi risiko kesalahan manusia. Manfaat utama menggunakan Terraform meliputi:

• Otomatisasi: Terraform mengotomatiskan proses penyediaan infrastruktur, menghemat waktu dan tenaga.
• Konsistensi: Terraform memastikan bahwa infrastruktur Anda disediakan secara konsisten, mengurangi risiko kesalahan konfigurasi.
• Dapat Diulang: Konfigurasi Terraform dapat diulang, memungkinkan Anda untuk dengan mudah membuat dan mengelola lingkungan yang sama beberapa kali.
• Kontrol Versi: Konfigurasi Terraform dapat dikelola dengan kontrol versi, memungkinkan Anda untuk melacak perubahan dan mengembalikan versi sebelumnya jika perlu.
• Kolaborasi: Terraform memfasilitasi kolaborasi dengan memungkinkan beberapa tim untuk bekerja pada infrastruktur yang sama.

Dalam konteks agen AI kita, Terraform dapat digunakan untuk menyediakan sumber daya yang diperlukan, seperti server, jaringan, dan penyimpanan, di cloud atau di tempat.

3. Arsitektur Agen AI: Gambaran Umum

Arsitektur agen AI kita terdiri dari komponen-komponen berikut:

1. Input Pengguna: Agen AI menerima input dari pengguna melalui berbagai saluran, seperti teks, suara, atau sensor.
2. Model Bahasa (Granite): Model bahasa memproses input pengguna dan menghasilkan respons atau tindakan.
3. Function Calling: Model bahasa dapat memanggil fungsi eksternal untuk mengakses data atau melakukan tindakan.
4. Alat/API: Alat dan API eksternal menyediakan fungsionalitas yang dapat diakses oleh agen AI melalui Function Calling.
5. Ollama: Ollama menyediakan lingkungan runtime untuk menjalankan model Granite secara lokal.
6. Output: Agen AI menghasilkan output, seperti teks, suara, atau tindakan.
7. Terraform: Terraform menyediakan dan mengelola infrastruktur yang mendasari (opsional, tetapi direkomendasikan untuk penerapan skala besar).

Diagram berikut menggambarkan arsitektur ini:

+-----------------+       +-----------------+       +-----------------+
|   Input Pengguna  |----->|  Model Bahasa   |----->| Function Calling |
|                 |       |   (Granite)     |       |                 |
+-----------------+       +-----------------+       +-----------------+
        ^                       |
        |                       |
        |                       v
        |                +-----------------+
        |                |      Ollama     |
        |                +-----------------+
        |                       |
        |                       v
+-----------------+       +-----------------+
|      Output       |<-----|   Alat/API      |
+-----------------+       +-----------------+

[Terraform (opsional) untuk penyediaan dan pengelolaan infrastruktur]

4. Langkah-Langkah Implementasi: Panduan Langkah demi Langkah

Sekarang, mari kita jalani langkah-langkah untuk mengimplementasikan agen AI dengan Function Calling, Ollama, Granite, dan Terraform.

Langkah 1: Menyiapkan Ollama

1. Unduh Ollama: Kunjungi situs web Ollama dan unduh versi yang sesuai untuk sistem operasi Anda.
2. Instal Ollama: Ikuti petunjuk instalasi yang disediakan di situs web.
3. Verifikasi Instalasi: Buka terminal dan jalankan perintah ollama --version. Ini akan menampilkan versi Ollama yang terinstal.

Langkah 2: Mengunduh dan Menjalankan Model Granite

1. Pilih Model Granite: Pilih model Granite yang paling sesuai dengan kebutuhan Anda. Pertimbangkan ukuran, kinerja, dan persyaratan sumber daya. Lihat dokumentasi IBM untuk opsi yang tersedia.
2. Unduh Model: Gunakan perintah ollama pull untuk mengunduh model Granite yang dipilih. Misalnya: ollama pull ibm/granite-13b-chat (Perhatikan bahwa nama model yang tepat mungkin berbeda, periksa dokumentasi Ollama dan IBM).
3. Jalankan Model: Setelah model diunduh, Anda dapat menjalankannya menggunakan perintah ollama run. Misalnya: ollama run ibm/granite-13b-chat.

Setelah model dijalankan, Anda dapat berinteraksi dengannya menggunakan API Ollama.

Langkah 3: Membuat Definisi Fungsi

Definisi fungsi menggambarkan fungsi eksternal yang dapat dipanggil oleh agen AI. Definisi ini harus mencakup informasi berikut:

• Nama: Nama fungsi.
• Deskripsi: Deskripsi fungsi.
• Parameter: Daftar parameter yang diterima oleh fungsi. Setiap parameter harus memiliki nama, deskripsi, dan tipe data.
• Tipe Kembalian: Tipe data nilai yang dikembalikan oleh fungsi.

Definisi fungsi biasanya diformat sebagai JSON. Berikut adalah contoh definisi fungsi untuk fungsi yang mencari informasi di web:

{
  "name": "search_web",
  "description": "Mencari informasi di web.",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Kueri pencarian."
      }
    },
    "required": ["query"]
  },
  "returns": {
    "type": "string",
    "description": "Hasil pencarian."
  }
}

Anda perlu membuat definisi fungsi untuk setiap alat atau API yang ingin Anda integrasikan dengan agen AI Anda.

Langkah 4: Mengimplementasikan Logika Agen AI dengan Function Calling

Logika agen AI bertanggung jawab untuk memproses input pengguna, memutuskan fungsi mana yang akan dipanggil, dan menghasilkan output. Proses ini biasanya melibatkan langkah-langkah berikut:

1. Terima Input Pengguna: Agen AI menerima input dari pengguna.
2. Proses Input: Agen AI memproses input menggunakan model bahasa (Granite).
3. Identifikasi Fungsi yang Akan Dipanggil: Model bahasa menentukan apakah perlu memanggil fungsi eksternal berdasarkan input. Ini dilakukan dengan mencari sinyal dalam output model yang menunjukkan kebutuhan untuk memanggil fungsi. Model yang dilatih untuk Function Calling akan sering kali menghasilkan respons dalam format tertentu yang menentukan nama fungsi yang akan dipanggil dan parameter yang harus diteruskan.
4. Panggil Fungsi: Jika fungsi perlu dipanggil, agen AI memanggil fungsi yang sesuai dengan parameter yang diperlukan.
5. Terima Hasil: Agen AI menerima hasil dari fungsi yang dipanggil.
6. Proses Hasil: Agen AI memproses hasil menggunakan model bahasa.
7. Hasilkan Output: Agen AI menghasilkan output ke pengguna.

Berikut adalah contoh sederhana tentang bagaimana Function Calling dapat bekerja di Python:

import ollama
import json

# Definisi Fungsi
def search_web(query):
  """Mencari informasi di web (stubs)."""
  print(f"Melakukan pencarian web untuk: {query}")
  # Di sini Anda akan mengganti dengan panggilan ke API pencarian web yang sebenarnya.
  return f"Hasil pencarian web untuk '{query}': Ini adalah hasil dummy."

# Fungsi untuk memanggil Ollama
def run_ollama(prompt, functions=None):
  response = ollama.chat(
    model='ibm/granite-13b-chat',  # Ganti dengan model Anda
    messages=[
      {
        'role': 'user',
        'content': prompt
      }
    ],
    options={
      'functions': functions  # Kirim daftar definisi fungsi
    }
  )
  return response['message']['content']

# Definisi Fungsi (sama seperti di atas)
function_definitions = [
    {
        "name": "search_web",
        "description": "Mencari informasi di web.",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "Kueri pencarian."
                }
            },
            "required": ["query"]
        }
    }
]

# Contoh Penggunaan
user_query = "Siapa presiden Perancis saat ini?"
prompt = f"Jawab pertanyaan berikut menggunakan alat yang tersedia: {user_query}"

# Panggil Ollama dengan definisi fungsi
response = run_ollama(prompt, function_definitions)

print(f"Respon Awal dari Model: {response}")

# Periksa apakah model meminta panggilan fungsi
if "function_call" in response:  #Perlu disesuaikan berdasarkan format respons model Granite
  function_call = json.loads(response["function_call"]) #Perlu disesuaikan berdasarkan format respons model Granite
  function_name = function_call["name"]
  arguments = function_call["arguments"]

  if function_name == "search_web":
    search_results = search_web(arguments["query"])
    print(f"Hasil Pencarian: {search_results}")

    # Kirim kembali hasil pencarian ke model
    second_prompt = f"Hasil pencarian: {search_results}. Jawab pertanyaan: {user_query}"
    final_response = run_ollama(second_prompt)
    print(f"Jawaban Akhir: {final_response}")

  else:
    print(f"Fungsi yang tidak dikenal dipanggil: {function_name}")
else:
  print("Model tidak meminta panggilan fungsi.")

Catatan Penting: Kode di atas adalah contoh sederhana dan membutuhkan penyesuaian berdasarkan format respons model Granite tertentu. Secara khusus, Anda perlu menyesuaikan cara Anda mengurai respons untuk mengidentifikasi panggilan fungsi dan argumennya. Periksa dokumentasi IBM untuk model Granite untuk rincian spesifik tentang format respons Function Calling mereka.

Framework seperti LangChain dan LlamaIndex juga menyederhanakan proses pembuatan agen AI dengan Function Calling dengan menyediakan abstraksi dan utilitas tingkat tinggi.

Langkah 5: Menggunakan Terraform untuk Penyediaan Infrastruktur

Jika Anda ingin menerapkan agen AI Anda pada skala besar, Anda dapat menggunakan Terraform untuk menyediakan infrastruktur yang diperlukan. Berikut adalah langkah-langkah dasarnya:

1. Tulis Konfigurasi Terraform: Buat file konfigurasi Terraform yang mendefinisikan sumber daya yang Anda butuhkan, seperti server, jaringan, dan penyimpanan.
2. Inisialisasi Terraform: Inisialisasi Terraform di direktori yang berisi file konfigurasi Anda menggunakan perintah terraform init.
3. Rencanakan Perubahan: Rencanakan perubahan yang akan dilakukan pada infrastruktur Anda menggunakan perintah terraform plan.
4. Terapkan Perubahan: Terapkan perubahan ke infrastruktur Anda menggunakan perintah terraform apply.

Contoh sederhana file Terraform untuk membuat instans AWS EC2:

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.0"
    }
  }
}

provider "aws" {
  region = "us-west-2"  # Ganti dengan wilayah AWS Anda
}

resource "aws_instance" "example" {
  ami           = "ami-0c55b5a45c56c5a13" # Ganti dengan AMI yang sesuai
  instance_type = "t2.micro"

  tags = {
    Name = "Ollama-Granite-Instance"
  }
}

output "public_ip" {
  value = aws_instance.example.public_ip
}

Ini hanyalah contoh dasar. Anda perlu menyesuaikan konfigurasi Terraform agar sesuai dengan kebutuhan spesifik Anda.

5. Contoh Kasus: Agen AI untuk Otomatisasi Tugas

Mari kita lihat beberapa contoh kasus tentang bagaimana agen AI dengan Function Calling dapat digunakan untuk mengotomatiskan tugas:

Contoh 1: Agen Penjadwalan Rapat

Agen penjadwalan rapat dapat mengotomatiskan proses penjadwalan rapat dengan memeriksa kalender orang yang berbeda, menemukan waktu yang tersedia, dan mengirim undangan.

Fungsi yang mungkin dipanggil agen:

• get_calendar(user_id): Mendapatkan kalender pengguna.
• find_available_slots(calendar, duration): Menemukan slot waktu yang tersedia di kalender.
• send_invitation(attendees, time, subject): Mengirim undangan rapat.

Contoh 2: Agen Pencarian Informasi

Agen pencarian informasi dapat menjawab pertanyaan dengan mencari informasi di web dan meringkas hasil.

Fungsi yang mungkin dipanggil agen:

• search_web(query): Mencari informasi di web.
• summarize_text(text): Meringkas teks.

Contoh 3: Agen Analisis Sentimen

Agen analisis sentimen dapat menganalisis sentimen teks dan menentukan apakah itu positif, negatif, atau netral.

Fungsi yang mungkin dipanggil agen:

• analyze_sentiment(text): Menganalisis sentimen teks.

6. Optimasi dan Tuning

Untuk mencapai kinerja optimal dari agen AI Anda, pertimbangkan teknik optimasi dan tuning berikut:

Prompt Engineering

Kualitas prompt yang Anda berikan ke model bahasa berdampak signifikan pada kinerjanya. Bereksperimenlah dengan prompt yang berbeda untuk menemukan yang menghasilkan hasil terbaik. Pertimbangkan tips berikut:

• Jelas dan Singkat: Buat prompt Anda jelas dan ringkas.
• Spesifik: Jadilah sespesifik mungkin tentang apa yang ingin Anda capai.
• Berikan Konteks: Berikan konteks yang cukup untuk membantu model bahasa memahami permintaan Anda.
• Gunakan Kata Kunci: Gunakan kata kunci yang relevan untuk memandu model bahasa.

Fine-tuning Model

Jika Anda membutuhkan kinerja yang lebih baik, Anda dapat menyempurnakan model bahasa Anda dengan data khusus Anda. Fine-tuning melibatkan pelatihan model pada dataset kecil yang relevan dengan aplikasi Anda. Ini dapat membantu model bahasa untuk beradaptasi dengan tugas spesifik Anda dan meningkatkan akurasi.

Pemantauan dan Log

Pantau kinerja agen AI Anda dan log semua kesalahan atau masalah. Ini akan membantu Anda untuk mengidentifikasi area untuk perbaikan dan memecahkan masalah apa pun yang mungkin timbul. Gunakan alat pemantauan dan logging untuk melacak metrik seperti latensi, akurasi, dan penggunaan sumber daya.

7. Keamanan dan Pertimbangan

Saat membangun agen AI, penting untuk mempertimbangkan keamanan dan etika. Berikut adalah beberapa pertimbangan penting:

• Keamanan Input: Validasi dan sanitasi semua input pengguna untuk mencegah serangan injeksi.
• Keamanan Fungsi: Amankan fungsi eksternal yang dipanggil oleh agen AI untuk mencegah akses yang tidak sah.
• Privasi Data: Lindungi privasi data pengguna dan patuhi peraturan yang relevan.
• Bias: Mitigasi bias dalam model bahasa dan data pelatihan.
• Transparansi: Buat agen AI transparan dan dapat dijelaskan.

8. Tantangan Umum dan Pemecahan Masalah

Berikut adalah beberapa tantangan umum yang mungkin Anda hadapi saat membangun agen AI dengan Function Calling dan saran pemecahan masalah:

• Format Respons yang Tidak Benar: Model bahasa mungkin tidak selalu menghasilkan respons dalam format yang benar untuk Function Calling. Pastikan Anda memahami format respons yang diharapkan dan tangani kesalahan apa pun yang mungkin timbul.
• Kesalahan Pemanggilan Fungsi: Fungsi eksternal mungkin gagal karena berbagai alasan, seperti kesalahan jaringan, kesalahan data, atau bug kode. Tangani kesalahan ini dengan anggun dan berikan pesan kesalahan yang informatif kepada pengguna.
• Masalah Kinerja: Model bahasa mungkin lambat atau mengonsumsi terlalu banyak sumber daya. Optimalkan model dan infrastruktur Anda untuk meningkatkan kinerja.
• Masalah Bias: Model bahasa mungkin menunjukkan bias. Kurangi bias dengan menggunakan data pelatihan yang beragam dan menerapkan teknik debiasing.

9. Kesimpulan: Masa Depan Agen AI dengan Function Calling

Function Calling adalah teknologi yang kuat yang memberdayakan agen AI untuk berinteraksi dengan dunia di sekitar mereka dan melakukan berbagai tugas. Dengan menggabungkan Function Calling dengan Ollama, Granite, dan Terraform, Anda dapat membangun agen AI yang kuat, fleksibel, dan dapat diskalakan yang dapat mengotomatiskan tugas, meningkatkan efisiensi, dan memberikan solusi inovatif. Saat teknologi terus berkembang, kita dapat mengharapkan untuk melihat agen AI menjadi lebih banyak digunakan dan terintegrasi ke dalam kehidupan kita sehari-hari.

10. Sumber Daya Tambahan

• Dokumentasi Ollama: https://ollama.ai/
• Model IBM Granite: Cari di IBM Developer atau IBM Research untuk publikasi dan dokumentasi model Granite terbaru.
• Dokumentasi Terraform: https://www.terraform.io/docs
• LangChain: https://www.langchain.com/
• LlamaIndex: https://www.llamaindex.ai/
• Artikel IBM tentang Function Calling dengan Model Granite: https://www.ibm.com/blog/function-calling-with-watsonx-granite-models/