Gemini 2.5 Pro API: Panduan dengan Proyek Demo

Menyambungkan ke API Gemini 2.5 Pro

Untuk mengakses model Gemini 2.5 Pro melalui Google API, ikuti langkah-langkah berikut:

1. Menyiapkan lingkungan

Pertama, instal paket Python google-genai. Jalankan perintah berikut di terminal Anda:

pip install google-genai

2. Membuat API key

Buka Google AI Studio dan buat API key Anda. Lalu, setel API key tersebut sebagai variabel lingkungan di sistem Anda.

3. Buat klien GenAI

Gunakan API key untuk menginisialisasi klien Google GenAI. Klien ini memungkinkan Anda berinteraksi dengan model Gemini 2.5 Pro.

import os
from google import genai
from google.genai import types
from IPython.display import Markdown, HTML, Image, display

API_KEY = os.environ.get("GEMINI_API_KEY")

client = genai.Client(api_key=API_KEY)

4. Muat file

Muat file Python yang ingin Anda kerjakan dan buat prompt untuk model.

# Load the Python file as text

file_path = "secure_app.py"
with open(file_path, "r") as file:
    doc_data = file.read()
prompt = "Please integrate user management into the FastAPI application."

contents = [
    types.Part.from_bytes(
        data=doc_data.encode("utf-8"),
        mime_type="text/x-python",
    ),
    prompt,
]

5. Hasilkan respons

Buat instance chat menggunakan model Gemini 2.5 Pro (gemini-2.5-pro-exp-03-25) dan berikan konten file beserta prompt. Model akan menganalisis kode dan menghasilkan respons.

chat = client.aio.chats.create(
    model="gemini-2.5-pro-exp-03-25",
    config=types.GenerateContentConfig(
        tools=[types.Tool(code_execution=types.ToolCodeExecution)]
    ),
)

response = await chat.send_message(contents)
Markdown(response.text)

Dalam hitungan detik, respons kontekstual akan dihasilkan.

Catatan: Akses gratis ke model mungkin saat ini tidak tersedia karena beban tinggi. Tunggu beberapa menit dan coba lagi.

6. Eksekusi kode (Eksperimental)

Anda juga dapat meminta model untuk mengeksekusi kode.

response = await chat.send_message('Please run the code to ensure that everything is functioning properly.')
Markdown(response.text)

Perlu dicatat bahwa fitur ini bersifat eksperimental dan memiliki keterbatasan. Misalnya, model tidak dapat menjalankan web server, mengakses sistem file, atau melakukan operasi jaringan.

Catatan: Model Gemini 2.5 Pro mencakup kemampuan "berpikir" tingkat lanjut. Meskipun terlihat di Google AI Studio, kemampuan tersebut tidak disertakan dalam output API.

Membangun Aplikasi Analisis Kode dengan Gemini 2.5 Pro

Aplikasi ini memungkinkan pengguna mengunggah file, termasuk beberapa file atau bahkan arsip ZIP berisi seluruh proyek, ke antarmuka berbasis chat. Pengguna dapat mengajukan pertanyaan tentang proyek mereka, memecahkan masalah, atau meningkatkan codebase. Berbeda dengan editor kode AI tradisional yang kesulitan dengan konteks besar karena keterbatasannya, Gemini 2.5 Pro dengan jendela konteks panjangnya dapat menganalisis dan menyelesaikan masalah secara efektif di seluruh proyek.

1. Menginstal pustaka yang diperlukan

Instal gradio untuk pembuatan UI dan zipfile36 untuk menangani file ZIP.

pip install gradio==5.14.0
pip install zipfile36==0.1.3

2. Menyiapkan klien dan UI

Impor paket Python yang diperlukan, definisikan variabel global, inisialisasi klien GenAI, tetapkan konstanta UI, dan buat daftar ekstensi file yang didukung.

import os
import zipfile
from typing import Dict, List, Optional, Union

import gradio as gr
from google import genai
from google.genai import types

# Retrieve API key for Google GenAI from the environment variables.
GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")

# Initialize the client so that it can be reused across functions.
CLIENT = genai.Client(api_key=GOOGLE_API_KEY)


# Global variables
EXTRACTED_FILES = {}

# Store chat sessions
CHAT_SESSIONS = {}

TITLE = """<h1 align="center">✨ Gemini Analisis Kode</h1>"""
AVATAR_IMAGES = (None, "https://media.roboflow.com/spaces/gemini-icon.png")


# List of supported text extensions (alphabetically sorted)
TEXT_EXTENSIONS = [
    ".bat",
    ".c",
    ".cfg",
    ".conf",
    ".cpp",
    ".cs",
    ".css",
    ".go",
    ".h",
    ".html",
    ".ini",
    ".java",
    ".js",
    ".json",
    ".jsx",
    ".md",
    ".php",
    ".ps1",
    ".py",
    ".rb",
    ".rs",
    ".sh",
    ".toml",
    ".ts",
    ".tsx",
    ".txt",
    ".xml",
    ".yaml",
    ".yml",
]

3. Fungsi: extract_text_from_zip

Fungsi extract_text_from_zip() mengekstrak konten teks dari file di dalam arsip ZIP dan mengembalikannya sebagai kamus.

def extract_text_from_zip(zip_file_path: str) -> Dict[str, str]:

    text_contents = {}

    with zipfile.ZipFile(zip_file_path, "r") as zip_ref:
        for file_info in zip_ref.infolist():
            # Skip directories
            if file_info.filename.endswith("/"):
                continue

            # Skip binary files and focus on text files
            file_ext = os.path.splitext(file_info.filename)[1].lower()

            if file_ext in TEXT_EXTENSIONS:
                try:
                    with zip_ref.open(file_info) as file:
                        content = file.read().decode("utf-8", errors="replace")
                        text_contents[file_info.filename] = content
                except Exception as e:
                    text_contents[file_info.filename] = (
                        f"Error extracting file: {str(e)}"
                    )

    return text_contents

4. Fungsi: extract_text_from_single_file

Fungsi extract_text_from_single_file() mengekstrak konten teks dari satu file dan mengembalikannya sebagai kamus.

def extract_text_from_single_file(file_path: str) -> Dict[str, str]:

    text_contents = {}
    filename = os.path.basename(file_path)
    file_ext = os.path.splitext(filename)[1].lower()

    if file_ext in TEXT_EXTENSIONS:
        try:
            with open(file_path, "r", encoding="utf-8", errors="replace") as file:
                content = file.read()
                text_contents[filename] = content
        except Exception as e:
            text_contents[filename] = f"Error reading file: {str(e)}"

    return text_contents

5. Fungsi: upload_zip

Fungsi upload_zip() memproses file yang diunggah, baik berformat ZIP maupun file teks, mengekstrak konten teksnya, dan menambahkan pesan ke chat.

def upload_zip(files: Optional[List[str]], chatbot: List[Union[dict, gr.ChatMessage]]):
    global EXTRACTED_FILES

    # Handle multiple file uploads
    if len(files) > 1:
        total_files_processed = 0
        total_files_extracted = 0
        file_types = set()

        # Process each file
        for file in files:
            filename = os.path.basename(file)
            file_ext = os.path.splitext(filename)[1].lower()

            # Process based on file type
            if file_ext == ".zip":
                extracted_files = extract_text_from_zip(file)
                file_types.add("zip")
            else:
                extracted_files = extract_text_from_single_file(file)
                file_types.add("text")

            if extracted_files:
                total_files_extracted += len(extracted_files)
                # Store the extracted content in the global variable
                EXTRACTED_FILES[filename] = extracted_files

            total_files_processed += 1

        # Create a summary message for multiple files
        file_types_str = (
            "files"
            if len(file_types) > 1
            else ("ZIP files" if "zip" in file_types else "text files")
        )

        # Create a list of uploaded file names
        file_list = "\n".join([f"- {os.path.basename(file)}" for file in files])

        chatbot.append(
            gr.ChatMessage(
                role="user",
                content=f"<p>📚 Multiple {file_types_str} uploaded ({total_files_processed} files)</p><p>Extracted {total_files_extracted} text file(s) in total</p><p>Uploaded files:</p><pre>{file_list}</pre>",
            )
        )

    # Handle single file upload (original behavior)
    elif len(files) == 1:
        file = files[0]
        filename = os.path.basename(file)
        file_ext = os.path.splitext(filename)[1].lower()

        # Process based on file type
        if file_ext == ".zip":
            extracted_files = extract_text_from_zip(file)
            file_type_msg = "📦 ZIP file"
        else:
            extracted_files = extract_text_from_single_file(file)
            file_type_msg = "📄 File"

        if not extracted_files:
            chatbot.append(
                gr.ChatMessage(
                    role="user",
                    content=f"<p>{file_type_msg} uploaded: {filename}, but no text content was found or the file format is not supported.</p>",
                )
            )
        else:
            file_list = "\n".join([f"- {name}" for name in extracted_files.keys()])
            chatbot.append(
                gr.ChatMessage(
                    role="user",
                    content=f"<p>{file_type_msg} uploaded: {filename}</p><p>Extracted {len(extracted_files)} text file(s):</p><pre>{file_list}</pre>",
                )
            )

            # Store the extracted content in the global variable
            EXTRACTED_FILES[filename] = extracted_files

    return chatbot

6. Fungsi: user

Fungsi user() menambahkan masukan teks pengguna ke riwayat percakapan chatbot.

def user(text_prompt: str, chatbot: List[gr.ChatMessage]):

    if text_prompt:
        chatbot.append(gr.ChatMessage(role="user", content=text_prompt))
    return "", chatbot

7. Fungsi: get_message_content

Fungsi get_message_content() mengambil konten pesan, yang bisa berupa kamus atau pesan chat Gradio.

def get_message_content(msg):
   
    if isinstance(msg, dict):
        return msg.get("content", "")
    return msg.content

8. Fungsi: send_to_gemini

Fungsi send_to_gemini() mengirim prompt pengguna ke Gemini AI dan men-stream respons kembali ke chatbot. Jika file kode diunggah, file-file tersebut akan disertakan dalam konteks.

def send_to_gemini(chatbot: List[Union[dict, gr.ChatMessage]]):

    global EXTRACTED_FILES, CHAT_SESSIONS

    if len(chatbot) == 0:
        chatbot.append(
            gr.ChatMessage(
                role="assistant",
                content="Please enter a message to start the conversation.",
            )
        )
        return chatbot

    # Get the last user message as the prompt
    user_messages = [
        msg
        for msg in chatbot
        if (isinstance(msg, dict) and msg.get("role") == "user")
        or (hasattr(msg, "role") and msg.role == "user")
    ]

    if not user_messages:
        chatbot.append(
            gr.ChatMessage(
                role="assistant",
                content="Please enter a message to start the conversation.",
            )
        )
        return chatbot

    last_user_msg = user_messages[-1]
    prompt = get_message_content(last_user_msg)

    # Skip if the last message was about uploading a file (ZIP, single file, or multiple files)
    if (
        "📦 ZIP file uploaded:" in prompt
        or "📄 File uploaded:" in prompt
        or "📚 Multiple files uploaded" in prompt
    ):
        chatbot.append(
            gr.ChatMessage(
                role="assistant",
                content="What would you like to know about the code in this ZIP file?",
            )
        )
        return chatbot

    # Generate a unique session ID based on the extracted files or use a default key for no files
    if EXTRACTED_FILES:
        session_key = ",".join(sorted(EXTRACTED_FILES.keys()))
    else:
        session_key = "no_files"

    # Create a new chat session if one doesn't exist for this set of files
    if session_key not in CHAT_SESSIONS:
        # Configure Gemini with code execution capability
        CHAT_SESSIONS[session_key] = CLIENT.chats.create(
            model="gemini-2.5-pro-exp-03-25",
        )

        # Send all extracted files to the chat session first
        initial_contents = []
        for zip_name, files in EXTRACTED_FILES.items():
            for filename, content in files.items():
                file_ext = os.path.splitext(filename)[1].lower()
                mime_type = "text/plain"

                # Set appropriate mime type based on file extension
                if file_ext == ".py":
                    mime_type = "text/x-python"
                elif file_ext in [".js", ".jsx"]:
                    mime_type = "text/javascript"
                elif file_ext in [".ts", ".tsx"]:
                    mime_type = "text/typescript"
                elif file_ext == ".html":
                    mime_type = "text/html"
                elif file_ext == ".css":
                    mime_type = "text/css"
                elif file_ext in [".json", ".jsonl"]:
                    mime_type = "application/json"
                elif file_ext in [".xml", ".svg"]:
                    mime_type = "application/xml"

                # Create a header with the filename to preserve original file identity
                file_header = f"File: {filename}\n\n"
                file_content = file_header + content

                initial_contents.append(
                    types.Part.from_bytes(
                        data=file_content.encode("utf-8"),
                        mime_type=mime_type,
                    )
                )

        # Initialize the chat context with files if available
        if initial_contents:
            initial_contents.append(
                "I've uploaded these code files for you to analyze. I'll ask questions about them next."
            )
            # Use synchronous API instead of async
            CHAT_SESSIONS[session_key].send_message(initial_contents)
        # For sessions without files, we don't need to send an initial message

    # Append a placeholder for the assistant's response
    chatbot.append(gr.ChatMessage(role="assistant", content=""))

    # Send the user's prompt to the existing chat session using streaming API
    response = CHAT_SESSIONS[session_key].send_message_stream(prompt)

    # Process the response stream - text only (no images)
    output_text = ""
    for chunk in response:
        if chunk.candidates and chunk.candidates[0].content.parts:
            for part in chunk.candidates[0].content.parts:
                if part.text is not None:
                    # Append the new chunk of text
                    output_text += part.text

                    # Update the last assistant message with the current accumulated response
                    if isinstance(chatbot[-1], dict):
                        chatbot[-1]["content"] = output_text
                    else:
                        chatbot[-1].content = output_text

                    # Yield the updated chatbot to show streaming updates in the UI
                    yield chatbot

    # Return the final chatbot state
    return chatbot

9. Fungsi: reset_app

Fungsi rest_app() mereset aplikasi dengan menghapus riwayat chat dan file yang diunggah.

def reset_app(chatbot):
    global EXTRACTED_FILES, CHAT_SESSIONS

    # Clear the global variables
    EXTRACTED_FILES = {}
    CHAT_SESSIONS = {}

    # Reset the chatbot with a welcome message
    return [
        gr.ChatMessage(
            role="assistant",
            content="App has been reset. You can start a new conversation or upload new files.",
        )
    ]

10. Komponen UI Gradio

Mari kita definisikan komponen Gradio: chatbot, input teks, tombol unggah, dan tombol kontrol.

# Define the Gradio UI components
chatbot_component = gr.Chatbot(
    label="Gemini 2.5 Pro",
    type="messages",
    bubble_full_width=False,
    avatar_images=AVATAR_IMAGES,
    scale=2,
    height=350,
)
text_prompt_component = gr.Textbox(
    placeholder="Ask a question or upload code files to analyze...",
    show_label=False,
    autofocus=True,
    scale=28,
)
upload_zip_button_component = gr.UploadButton(
    label="Upload",
    file_count="multiple",
    file_types=[".zip"] + TEXT_EXTENSIONS,
    scale=1,
    min_width=80,
)

send_button_component = gr.Button(
    value="Send", variant="primary", scale=1, min_width=80
)
reset_button_component = gr.Button(
    value="Reset", variant="stop", scale=1, min_width=80
)

# Define input lists for button chaining
user_inputs = [text_prompt_component, chatbot_component]

11. Tata letak aplikasi Gradio

Mari kita susun antarmuka Gradio menggunakan baris dan kolom agar rapi.

with gr.Blocks(theme=gr.themes.Ocean()) as demo:
    gr.HTML(TITLE)
    with gr.Column():
        chatbot_component.render()
        with gr.Row(equal_height=True):
            text_prompt_component.render()
            send_button_component.render()
            upload_zip_button_component.render()
            reset_button_component.render()

    # When the Send button is clicked, first process the user text then send to Gemini
    send_button_component.click(
        fn=user,
        inputs=user_inputs,
        outputs=[text_prompt_component, chatbot_component],
        queue=False,
    ).then(
        fn=send_to_gemini,
        inputs=[chatbot_component],
        outputs=[chatbot_component],
        api_name="send_to_gemini",
    )

    # Allow submission using the Enter key
    text_prompt_component.submit(
        fn=user,
        inputs=user_inputs,
        outputs=[text_prompt_component, chatbot_component],
        queue=False,
    ).then(
        fn=send_to_gemini,
        inputs=[chatbot_component],
        outputs=[chatbot_component],
        api_name="send_to_gemini_submit",
    )

    # Handle ZIP file uploads
    upload_zip_button_component.upload(
        fn=upload_zip,
        inputs=[upload_zip_button_component, chatbot_component],
        outputs=[chatbot_component],
        queue=False,
    )

    # Handle Reset button clicks
    reset_button_component.click(
        fn=reset_app,
        inputs=[chatbot_component],
        outputs=[chatbot_component],
        queue=False,
    )

12. Menjalankan aplikasi

Mari kita jalankan aplikasi Gradio secara lokal dengan antrean diaktifkan untuk menangani beberapa permintaan.

# Launch the demo interface
demo.queue(max_size=99, api_open=False).launch(
    debug=False,
    show_error=True,
    server_port=9595,
    server_name="localhost",
)

Menguji Aplikasi Analisis Kode Gemini 2.5 Pro

Untuk menjalankan aplikasi web, gabungkan semua sumber kode di atas ke dalam file main.py (yang saya unggah ke GitHub agar Anda mudah menyalinnya). Jalankan dengan perintah berikut:

python main.py

Aplikasi web akan tersedia di URL: http://localhost:9595/

Anda dapat menyalin URL tersebut dan menempelkannya ke peramban web Anda.

Seperti yang terlihat, aplikasi web ini memiliki antarmuka chatbot. Kita dapat menggunakannya layaknya ChatGPT.

Tombol "Upload" mendukung unggahan file tunggal dan ganda, serta file zip untuk proyek Anda. Jadi, jangan khawatir jika proyek Anda berisi lebih dari 20 file; aplikasi analisis kode ini dapat memprosesnya dan mengirimkannya ke Gemini 2.5 Pro API.

Mari unggah beberapa file dan minta Gemini 2.5 Pro untuk meningkatkan proyek kita. 

Seperti yang terlihat, model memberikan saran peningkatan yang tepat.

Kita dapat memintanya untuk mengimplementasikan semua saran ke dalam file secure_app.py.

Jika Anda ingin mengerjakan proyek lain, Anda dapat mengeklik tombol "Reset" dan mulai berdiskusi tentang proyek baru.

Source code dan konfigurasinya tersedia di repositori GitHub: kingabzpro/Gemini-2.5-Pro-Coding-App.

Kesimpulan

Membangun aplikasi AI yang andal kini jauh lebih mudah. Alih-alih membuat aplikasi kompleks dengan alat seperti LangChain, mengintegrasikan vector store, mengoptimalkan prompt, atau menambahkan rantai penalaran, kita cukup menginisialisasi klien Gemini 2.5 Pro melalui Google API. Gemini 2.5 Pro Chat API dapat menangani berbagai jenis file secara langsung, memungkinkan pertanyaan lanjutan, dan memberikan respons yang sangat akurat.