Gemini 2.0 Flash: Tutorial Langkah demi Langkah dengan Proyek Demo

Langkah 1: Siapkan Kunci API untuk Google AI Studio

Untuk menyiapkan kunci API, buka Google AI Studio dan klik tombol “Create API Key”. Ingat untuk menyalin kuncinya lalu tempel ke sebuah berkas bernama .env, dengan format berikut:

GOOGLE_API_KEY=replace_this_with_api_key

Jika Anda sudah pernah menggunakan Google Cloud Platform dengan akun Google yang sama, Google AI Studio akan meminta Anda memilih salah satu proyek untuk mengaktifkan API.

Untuk mengikuti tutorial ini, kode Python harus berada di folder yang sama dengan berkas .env.

Langkah 2: Instal Dependensi Python

Untuk proyek ini, kita akan menggunakan paket berikut:

• google-genai: Pustaka Python untuk mengintegrasikan model AI generatif Google ke dalam aplikasi kita.
• pyautogui: Pustaka lintas platform untuk mengontrol mouse dan keyboard secara terprogram guna mengotomatiskan tugas. Dalam kasus kita, ini digunakan untuk memberikan konten layar ke model AI.
• python-dotenv: Pustaka untuk mengelola variabel lingkungan dengan memuatnya dari berkas .env ke aplikasi Python kita.
• sounddevice: Pustaka Python untuk merekam dan memutar suara menggunakan API sederhana untuk input dan output audio.
• numpy: Pustaka fundamental untuk komputasi numerik di Python, menyediakan dukungan untuk array, matriks, dan berbagai operasi matematika.

Untuk menginstal dependensi, kita dapat menggunakan pip:

pip install google-genai pyautogui python-dotenv sounddevice numpy

Sebagai alternatif, kita unduh berkas requirements.txt dari repositori GitHub yang saya siapkan untuk proyek ini dan menggunakannya untuk membuat lingkungan Conda:

conda create --name gemini python=3.11
conda activate gemini
pip install -r requirements.txt

Langkah 3: Buat Chatbot Teks dengan Google GenAI API

Mari mulai dengan membuat antarmuka chat AI sederhana di command line menggunakan model Gemini 2 Flash dari Google dengan pustaka google.genai. Saya sarankan meninjau dokumentasi resmi Gemini 2.0 jika terjadi kendala di sepanjang jalan.

Kode lengkap untuk contoh ini tersedia di berkas text.py dari repositori GitHub saya.

Membuat dan terhubung ke klien Google GenAI

Langkah pertama adalah memuat kunci API secara aman dan menginisialisasi klien Google GenAI. Skrip menggunakan dotenv untuk memuat variabel lingkungan dari berkas .env.

Berikut cara menyiapkan klien dengan kredensial yang diperlukan:

from google import genai
from dotenv import load_dotenv
import os

# Load environment variables from a .env file
load_dotenv()
client = genai.Client(
    api_key=os.getenv("GOOGLE_API_KEY"),
    http_options={"api_version": "v1alpha"},
)

print("Connected to the AI model!")

Melakukan panggilan API asinkron

Saat bekerja dengan API seperti Google GenAI, kita sering perlu menangani operasi asinkron. Pemrograman asinkron memungkinkan operasi lain tetap berjalan sembari menunggu permintaan jaringan, membuat aplikasi lebih responsif. Ini sangat penting saat menangani operasi latensi tinggi seperti permintaan jaringan.

Di Python, pemrograman asinkron dimungkinkan menggunakan pustaka asyncio dan sintaks async/await.

Berikut cara melakukan permintaan asinkron ke Google GenAI:

from google import genai
from dotenv import load_dotenv
import os
import asyncio

# Load environment variables from a .env file
load_dotenv()
async def main():
    client = genai.Client(
        api_key=os.getenv("GOOGLE_API_KEY"),
        http_options={"api_version": "v1alpha"},
    )    
    # Define the AI model and configuration
    model_id = "gemini-2.0-flash-exp"
    config = {"response_modalities": ["TEXT"]}
    async with client.aio.live.connect(model=model_id, config=config) as session:
        await session.send("Hello", end_of_turn=True)
        # Process responses from the AI
        async for response in session.receive():
            if not response.server_content.turn_complete:
                for part in response.server_content.model_turn.parts:
                    print(part.text, end="", flush=True)

# Run the main function
asyncio.run(main())

Versi ini terhubung ke model AI dan mengirim satu pesan “Hello”. Respons dicetak kata demi kata ke konsol.

Membuatnya interaktif

Agar aplikasi menjadi interaktif dan memungkinkan pengguna mengobrol bolak-balik dengan model AI, kita tambahkan loop yang membuat pengguna dapat mengirim banyak pesan. Loop berlanjut hingga pengguna mengetik "exit."

from google import genai
from dotenv import load_dotenv
import os
import asyncio

# Load environment variables from a .env file
load_dotenv()
async def main():
    client = genai.Client(
        api_key=os.getenv("GOOGLE_API_KEY"),
        http_options={"api_version": "v1alpha"},
    )
    # Define the AI model and configuration
    model_id = "gemini-2.0-flash-exp"
    config = {"response_modalities": ["TEXT"]}
    async with client.aio.live.connect(model=model_id, config=config) as session:
        while True:
            message = input("> ")
            print()
            # Exit the loop if the user types "exit"
            if message == "exit":
                print("Exiting...")
                break
            # Send the user's message to the AI model, marking the end of the turn
            await session.send(message, end_of_turn=True)
            # Receive responses asynchronously and process each response
            async for response in session.receive():
                if not response.server_content.turn_complete:
                    for part in response.server_content.model_turn.parts:
                        print(part.text, end="", flush=True)
            print()

# Run the main function
asyncio.run(main())

Selesai! Dengan skrip di atas, kita telah membuat chatbot AI di command line menggunakan Google GenAI API. Berikut tampilannya:

Langkah 4: Tambahkan Mode Audio

Mode audio memungkinkan model merespons dengan suara alih-alih teks. Untuk menyesuaikan contoh sebelumnya agar menangani respons audio, kita:

1. Mengimpor sounddevice untuk pemutaran audio dan numpy untuk memproses data audio.
2. Mengubah modality respons dari TEXT menjadi AUDIO:

	config = {"response_modalities": ["AUDIO"]} 

3. Menginisialisasi stream audio sebelum terhubung ke klien:

	with sd.OutputStream(
	samplerate=24000, 
	channels=1, 
	dtype="int16",
) as audio_stream:

4. Mengakses data audio dari bagian respons dan menambahkannya ke stream audio untuk diputar:

for part in response.server_content.model_turn.parts:
    # Get the audio data from the response part and add it to the steam
    inline_data = part.inline_data
    audio_data = np.frombuffer(inline_data.data, dtype="int16")
    audio_stream.write(audio_data)

Berkas audio.py di repositori memuat skrip lengkap dengan perubahan ini diterapkan. Skrip memuat komentar pada baris-baris yang diubah.

Langkah 5: Tambahkan Eksekusi Kode dengan Tools

Salah satu fitur hebat dari model AI modern adalah kemampuannya untuk secara otonom memanggil fungsi kustom dalam kode kita, dan Gemini 2 tidak terkecuali.

Cara kerjanya adalah kita memberi tahu model fungsi mana yang tersedia untuk dipanggil dengan mendaftarkannya sebagai tool. Lalu, dengan menganalisis prompt, nama dan deskripsi fungsi, model akan memutuskan apakah ia ingin melakukan pemanggilan fungsi. Saat memutuskan untuk melakukannya, ia akan mengirim respons khusus dengan nama fungsi yang ingin dipanggil beserta argumennya.

Untuk mendefinisikan sebuah tool, kita perlu:

1. Menulis fungsi Python dengan nama dan argumen yang sama seperti yang ditentukan dalam skema.
2. Membuat skema fungsi, yaitu dictionary berisi metadata tentang fungsi, seperti namanya, deskripsi tekstual, dan spesifikasi argumen.
3. Memberikan skema fungsi ke model AI.
4. Mengeksekusi fungsi saat diminta oleh model.

Untuk mengilustrasikannya, mari definisikan tool yang dapat membaca berkas, sehingga model dapat menjawab pertanyaan tentang berkas di mesin lokal kita.

Mendefinisikan fungsi

Bagian ini hanyalah kode Python biasa. Model mengharapkan jawaban berupa dictionary dengan kunci ”result” jika fungsi berhasil dan ”error” jika sebaliknya.

def load_file_content(filename):
    try:
      with open(filename, "rt") as f:
          return {
              "result": f.read()
          }
    except Exception as e:
      return {
          "error": "Could not load file content",
      }

Menentukan skema

Berikut cara kita dapat mendefinisikan skema untuk fungsi ini:

load_file_content_schema = {
    "name": "load_file_content",
    "description": "Load the content of a file",
    "parameters": {
        "type": "object",
        "properties": {
            "filename": {
                "type": "string",
                "description": "The name of the file",
            },
        },
        "required": ["filename"],
    },
    "output": {
        "type": "string",
        "description": "The text content of the file",
    },
}

Kita menyediakan empat field:

• ”name”: Nama fungsi.
• ”description”: Deskripsi tekstual. Ini digunakan oleh model untuk memutuskan apakah akan memanggil fungsi tersebut.
• ”properties”: Deskripsi argumen fungsi.
• ”output”: Deskripsi keluaran fungsi.

Lihat dokumentasi resmi untuk informasi lebih lanjut tentang skema fungsi.

Menyediakan fungsi ke model

Agar model mengetahui fungsi kita, kita memberikan skema fungsi dalam konfigurasi model:

config = {
       "tools": [{"function_declarations": [load_file_content_schema]}], 
       "response_modalities": ["TEXT"]
}

Memproses permintaan pemanggilan fungsi dari model

Ketika model memutuskan untuk melakukan pemanggilan fungsi, ia akan menambahkan tool_call ke response. Ini akan berisi nama fungsi dan argumennya. Bisa jadi ada beberapa permintaan pemanggilan, jadi kita perlu mengiterasi semuanya, memanggil fungsi yang sesuai, dan mengirimkan hasilnya kembali ke model:

# A dictionary mapping the function names to the actual functions
FUNCTIONS = {"load_file_content": load_file_content}
if response.tool_call is not None:
    for fc in tool_call.function_calls:
        f = FUNCTIONS.get(fc.name)
        tool_response = types.LiveClientToolResponse(
            function_responses=[
                types.FunctionResponse(
                    name=fc.name,
                    id=fc.id,
                    response=f(**fc.args),
                )
            ]
        )
    await session.send(tool_response)

Implementasi lengkap contoh ini tersedia di berkas tool.py di repositori yang memuat skrip lengkap dengan perubahan ini diterapkan. Definisi fungsi dan skema ada di berkas tool_spec.py.

Akses web

Dengan tools, kita juga dapat memberi kemampuan akses web kepada model dengan menambahkan Google search tool:

search_tool = {"google_search": {}}
config = {
    "tools": [search_tool],
    "response_modalities": ["TEXT"],
}

Tool ini sudah terpasang (built-in), sehingga kita tidak perlu menyediakan fungsi.

Eksekusi kode

Fungsi bawaan lain adalah eksekusi kode. Eksekusi kode memungkinkan model menulis dan menjalankan kode Python untuk menjawab pertanyaan kompleks, biasanya yang melibatkan matematika. Misalnya, dengan tool ini, jika kita memintanya menghitung jumlah 10 bilangan prima pertama, ia akan terlebih dahulu menulis kode Python untuk menghitungnya, mengeksekusinya, lalu memberikan jawabannya.

Untuk mengaktifkan tool ini, kita lakukan:

code_execution_tool = {"code_execution": {}}
config = {
    "tools": [code_execution_tool],
    "response_modalities": ["TEXT"],
}

Berikut contoh perilaku model dengan eksekusi kode:

​​> add the first 10 prime numbers
Okay, I understand. You want me to add the first 10 prime numbers.
Here's my plan:
1. **Identify the first 10 prime numbers:** I will use a python code to find prime numbers.
2. **Sum the prime numbers:** I will also sum them using python.
3. **Report the result**
The first 10 prime numbers are 2, 3, 5, 7, 11, 13, 17, 19, 23, and 29.  Their sum is 129.

Langkah 6: Bangun Asisten Visual

Di bagian terakhir ini, kita mengeksplorasi kemampuan visual Gemini 2. Tujuannya adalah membuat asisten AI yang dapat memahami konten di layar kita dan menjawab pertanyaan tentangnya. Ini bisa berguna, misalnya, saat kita memintanya menjelaskan kesalahan yang terlihat di terminal atau memberikan informasi tentang sesuatu yang sedang ditampilkan di layar.

Pada contoh sebelumnya, kita menggunakan pemrograman asinkron untuk terhubung ke model AI dan mengirim data bolak-balik sambil memproses respons secara real time. Sayangnya, versi SDK saat ini belum mendukung komunikasi real-time dengan gambar. Sebagai gantinya, kita memberikan data gambar melalui alur kerja request-response. Perlu dicatat bahwa ini bukan keterbatasan Gemini 2.0 itu sendiri—hanya saja API beta saat ini belum mendukungnya.

Mengirim permintaan sinkron ke Google GenAI

Mari mulai dengan mempelajari cara mengirim permintaan dengan data gambar ke Google GenAI API. Berikut cara kita dapat mengirim permintaan sinkron:

from google import genai
from dotenv import load_dotenv
import os

load_dotenv()

client = genai.Client(
    api_key=os.getenv("GOOGLE_API_KEY"),
    http_options={"api_version": "v1alpha"},
)

response = client.models.generate_content(
    model="gemini-2.0-flash-exp",
    contents=["Hello"],
)

print(response.text)

Perbedaan utama pada contoh ini adalah kita menggunakan client.models.generate_content untuk mengirim permintaan ke API. Ini adalah permintaan sinkron, yang berarti tidak memberikan pengalaman percakapan real-time.

Mengirim gambar

Kita dapat mengirim gambar dengan memuatnya dan menambahkannya ke daftar contents. Kita menggunakan paket PIL untuk membuat fungsi bernama load_and_resize_image() yang memuat dan mengubah ukuran gambar.

from PIL import Image

def load_and_resize_image(image_path):
    with Image.open(image_path) as img:
        aspect_ratio = img.height / img.width
        new_height = int(img.width * aspect_ratio)
        return img.resize((img.width, new_height), Image.Resampling.LANCZOS)    

image = load_and_resize_image("example_image.jpeg")

response = client.models.generate_content(
    model="gemini-2.0-flash-exp",
    contents=["Describe the image", image],
)

print(response.text)

Membuat asisten visual AI

Asisten visual AI memproses prompt tekstual bersama dengan tangkapan layar untuk membantu kita menjawab pertanyaan tentang apa yang ada di layar. Saya telah banyak bereksperimen, dan model dapat memahami konten layar bahkan saat beberapa jendela terbuka.

Cara paling sederhana untuk memberikan konten layar ke model adalah dengan mengambil tangkapan layar. Untuk ini, kita menggunakan paket pyautogui, pustaka lintas platform untuk mengontrol mouse dan keyboard secara terprogram guna mengotomatiskan tugas. Dalam kasus kita, kita hanya akan menggunakannya untuk mengambil tangkapan layar, meskipun fungsinya dapat diperluas agar AI dapat melakukan tugas di komputer kita secara otonom.

Berikut fungsi untuk mengambil tangkapan layar:

def capture_screen():
    timestamp = time.strftime("%Y%m%d-%H%M%S")
    filename = f"screenshot_{timestamp}.jpeg"
    screenshot = pyautogui.screenshot()
    screenshot = screenshot.convert("RGB")
    screenshot.save(filename, format="JPEG")
    return filename

Agar interaktif, kita ulangi langkah-langkah berikut sampai pengguna memutuskan keluar dari aplikasi:

1. Meminta pengguna memasukkan prompt.
2. Mengambil tangkapan layar dan mengirimkannya ke model AI bersama dengan prompt.
3. Menampilkan hasil kepada pengguna.

Kita perlu mengingat satu hal dengan pendekatan ini. Aplikasi akan berjalan di terminal, yang juga ditampilkan di layar. Oleh karena itu, lebih baik menginstruksikan model untuk mengabaikan jendela terminal. Ini dapat dilakukan dengan menambahkan system_instruction ke konfigurasi:

client.models.generate_content(
        model="gemini-2.0-flash-exp",
        contents=[prompt, screen],
        config=types.GenerateContentConfig(
            system_instruction="Ignore the terminal window in the image when analyzing the image",
        ),
)

Jika digabungkan, berikut asisten AI visual kita. Berkas dengan kode lengkap juga tersedia sebagai berkas vision.py di repositori.

from google import genai
from google.genai import types
from PIL import Image
import pyautogui
import time
import os
from dotenv import load_dotenv
load_dotenv()

# Initialize the GenAI client
client = genai.Client(
    api_key=os.getenv("GOOGLE_API_KEY"),
    http_options={"api_version": "v1alpha"},
)
def capture_screen():
    timestamp = time.strftime("%Y%m%d-%H%M%S")
    filename = f"screenshot_{timestamp}.jpeg"
    screenshot = pyautogui.screenshot()
    screenshot = screenshot.convert("RGB")
    screenshot.save(filename, format="JPEG")
    return filename

def load_and_resize_image(image_path):
    with Image.open(image_path) as img:
        aspect_ratio = img.height / img.width
        new_height = int(img.width * aspect_ratio)
        return img.resize((img.width, new_height), Image.Resampling.LANCZOS)    

def get_genai_response(prompt):
    print("Analyzing screen...")
    screen = load_and_resize_image(capture_screen())
    response = client.models.generate_content(
        model="gemini-2.0-flash-exp",
        contents=[prompt, screen],
        config=types.GenerateContentConfig(
            system_instruction="Ignore the terminal window in the image when analyzing the image",
        ),
    )
    return response.text

def main():
    while True:
        prompt = input("> ")
        print()
        if prompt == "exit":
            break
        answer = get_genai_response(prompt)
        print(answer)
        print()

if __name__ == "__main__":
    main()

Versi saat ini masih agak canggung karena mengharuskan terminal terbuka di atas tampilan saat ini untuk memicunya. Langkah berikut yang alami adalah menjalankannya di latar belakang dan menggunakan input serta output suara alih-alih teks.

Penutup

Kita telah mempelajari cara menggunakan model Gemini 2.0 Flash untuk berbagai aplikasi, seperti mengembangkan chatbot yang dapat terlibat dalam percakapan real-time dengan teks dan suara, memungkinkan model AI melakukan tindakan menggunakan pemanggilan fungsi, serta asisten visual yang mampu menganalisis konten layar komputer kita.

Jika Anda ingin mengeksplorasi lebih jauh, Google menyediakan dua contoh yang menunjukkan kemampuan model untuk mendeteksi objek dalam gambar dengan memberikan bounding box beserta labelnya. Contoh ini berfokus pada pemahaman spasial 2D dengan meminta model mengidentifikasi dan memberi label cupcake dalam gambar. Gemini juga dapat memahami konteks 3D dari sebuah gambar, seperti ditunjukkan di sini.

Secara keseluruhan, Gemini 2.0 cukup menjanjikan meskipun versi API saat ini belum memungkinkan kita menggunakannya secara penuh. Saya antusias untuk segera dapat menggunakan kemampuan multimodal real-time secara menyeluruh.