AI Prompt Engineering · Pelajaran

Pemanggilan Fungsi dan Integrasi API

Kuasai cara meminta LLM memanggil fungsi atau API eksternal agar dapat berinteraksi dengan sistem dunia nyata.

Pemanggilan Fungsi dan Integrasi API adalah pelajaran AI Prompt Engineering gratis di CoddyKit. Ini adalah pelajaran 1 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Prompt Engineering, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Prompt Engineering mencakup 3 pelajaran total.

Memanggil Alat Eksternal

LLM memang ampuh, tetapi pada dasarnya beroperasi di dunia teks. Bagaimana jika LLM memerlukan informasi dunia nyata atau perlu melakukan tindakan?

Pemanggilan fungsi memungkinkan LLM berinteraksi dengan alat eksternal dan API! Hal ini menjembatani kesenjangan antara bahasa dan tindakan, sehingga AI dapat:

Mendapatkan informasi terkini (cuaca, harga saham)
Melakukan tindakan (mengirim surel, memesan janji temu)
Terhubung ke basis data atau alat khusus

Hal ini membuka berbagai kemungkinan baru bagi sistem AI.

Peran LLM: Mengusulkan Pemanggilan

Saat Anda mengaktifkan pemanggilan fungsi, Anda memberikan deskripsi alat yang tersedia (fungsi) kepada LLM.

Alih-alih menjawab secara langsung, LLM dapat memutuskan bahwa suatu alat dapat membantu. LLM kemudian menghasilkan "usulan" terstruktur untuk pemanggilan fungsi, termasuk nama fungsi dan argumennya.

Penting: LLM tidak menjalankan fungsi itu sendiri. LLM hanya memberi tahu aplikasi Anda fungsi mana yang harus dipanggil dan dengan input apa.

Mendefinisikan Alat Anda

Untuk menggunakan pemanggilan fungsi, Anda harus mendefinisikan alat (fungsi) dengan cara yang dapat dipahami LLM. Biasanya, Anda perlu memberikan:

nama fungsi (misalnya, get_current_weather)
deskripsi tentang fungsinya (penting agar LLM dapat memilih dengan tepat)
parameter yang diterimanya, termasuk jenis dan deskripsinya (misalnya, location: string)

"Skema" ini memberi tahu LLM semua hal yang perlu diketahui untuk mengusulkan pemanggilan yang valid.

Definisi Alat Cuaca

Berikut definisi konseptual Python untuk alat cuaca. Perhatikan deskripsi dan parameternya yang jelas. Inilah yang akan Anda sediakan untuk LLM.

Fungsi ini merepresentasikan alat eksternal yang secara konseptual akan "dipanggil" oleh LLM.

def get_current_weather(location: str, unit: str = "celsius"):
    """
    Get the current weather in a given location.
    Args:
        location (str): The city and state, e.g. "London, UK"
        unit (str): The unit of temperature, "celsius" or "fahrenheit"
    Returns:
        dict: Weather information.
    """
    # In a real app, this would call a weather API
    if location == "London, UK":
        return {"temperature": "15", "unit": unit, "forecast": "cloudy"}
    elif location == "New York, USA":
        return {"temperature": "20", "unit": unit, "forecast": "sunny"}
    else:
        return {"temperature": "N/A", "unit": unit, "forecast": "unknown"}

Menyusun Prompt untuk Alat

Untuk mendorong LLM menggunakan alat Anda, prompt harus menyatakan maksud pengguna dengan jelas. LLM kemudian memutuskan apakah suatu alat dapat membantu.

Anda tidak perlu memberi tahu LLM secara eksplisit, "panggil get_weather". Sebagai gantinya, ajukan pertanyaan yang menyiratkan kebutuhan tersebut:

"Bagaimana cuaca di London?"
"Bisakah Anda memesankan rapat untuk saya besok?"

Dengan berbekal deskripsi alat, LLM akan menyimpulkan perlunya pemanggilan fungsi.

Usulan Pemanggilan oleh LLM

Saat LLM memutuskan untuk menggunakan suatu alat, LLM tidak memberikan jawaban langsung kepada Anda. Sebagai gantinya, LLM mengembalikan objek terstruktur, biasanya JSON, yang menunjukkan fungsi yang harus dipanggil dan argumennya.

Aplikasi Anda kemudian mengurai keluaran ini.

Berikut contoh usulan LLM jika ditanya "Bagaimana cuaca di London?":

{
  "tool_calls": [
    {
      "id": "call_abc123",
      "function": {
        "name": "get_current_weather",
        "arguments": "{\"location\": \"London, UK\", \"unit\": \"celsius\"}"
      },
      "type": "function"
    }
  ]
}

Aplikasi Anda Menjalankan Alat

Setelah menerima usulan pemanggilan fungsi dari LLM, aplikasi Anda mengambil alih:

Aplikasi mengidentifikasi fungsi yang diminta (misalnya, get_current_weather).
Aplikasi mengekstrak argumennya (misalnya, "London, UK").
Aplikasi menjalankan fungsi Python yang sebenarnya (atau melakukan pemanggilan API) di dalam lingkungan aplikasi Anda.

Di sinilah tindakan "dunia nyata" berlangsung di luar LLM.

LLM Memproses Keluaran Alat

Setelah aplikasi Anda menjalankan fungsi, aplikasi menerima hasil (misalnya, {"temperature": "15", ...}).

Hasil ini kemudian dikirim kembali ke LLM, bersama riwayat percakapan awal dan permintaan pemanggilan fungsi.

LLM kemudian menggunakan informasi baru ini untuk menghasilkan respons dalam bahasa alami terhadap pertanyaan awal pengguna.

Interaksi Ujung ke Ujung

Mari kita rangkai semuanya. Contoh ini menunjukkan alur ketika pertanyaan pengguna memicu LLM untuk mengusulkan pemanggilan fungsi, aplikasi Anda menjalankannya, lalu LLM memberikan jawaban akhir.

Ini merupakan gambaran sederhana dari siklus interaksi.

def get_current_weather(location, unit="celsius"):
    if location == "London, UK":
        return {"temp": "15", "unit": unit, "forecast": "cloudy"}
    return {"temp": "N/A", "unit": unit, "forecast": "unknown"}

def simulate_llm_response(user_query):
    # LLM 'thinks' and decides to call a tool
    if "weather in London" in user_query:
        return {
            "type": "tool_call",
            "function": "get_current_weather",
            "args": {"location": "London, UK"}
        }
    return {"type": "text", "content": "I cannot help with that."}

def simulate_llm_final_response(tool_output):
    # LLM processes tool output and gives natural language
    temp = tool_output.get("temp", "N/A")
    forecast = tool_output.get("forecast", "unknown")
    return f"The weather in London is {temp} degrees and {forecast}."

def main():
    user_input = "What is the weather in London, UK?"
    print(f"User: {user_input}")

    llm_output = simulate_llm_response(user_input)

    if llm_output["type"] == "tool_call":
        func_name = llm_output["function"]
        func_args = llm_output["args"]
        print(f"LLM suggested calling: {func_name}({func_args})")

        # Execute the function
        tool_result = get_current_weather(**func_args)
        print(f"Tool output: {tool_result}")

        # Feed result back to LLM
        final_answer = simulate_llm_final_response(tool_result)
        print(f"LLM's final answer: {final_answer}")
    else:
        print(f"LLM: {llm_output['content']}")

if __name__ == "__main__":
    main()

Pemeriksaan Pemanggilan Fungsi

Bayangkan LLM mengembalikan permintaan pemanggilan fungsi. Apa langkah berikutnya yang harus segera dilakukan aplikasi Anda?

Ringkasan: Alat dalam Tindakan

Dalam pelajaran ini, kita mengeksplorasi cara LLM berinteraksi dengan dunia nyata melalui pemanggilan fungsi dan integrasi API.

Kita mempelajari bahwa:

Anda mendefinisikan alat (fungsi) dengan deskripsi dan parameter.
LLM mengusulkan alat yang harus dipanggil beserta argumennya.
Aplikasi Anda menjalankan alat yang sebenarnya dan mengirimkan hasilnya kembali.
LLM kemudian menggunakan hasil tersebut untuk merumuskan respons akhir yang informatif.

Teknik ampuh ini memungkinkan LLM melakukan lebih dari sekadar menghasilkan teks, sehingga LLM dapat melakukan tindakan dan mengambil informasi terbaru.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pemanggilan Fungsi dan Integrasi API” gratis?

Ya — teks lengkap “Pemanggilan Fungsi dan Integrasi API” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Prompt Engineering, upgrade ke CoddyKit PRO. Kursus AI Prompt Engineering mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Pemanggilan Fungsi dan Integrasi API”?

Kuasai cara meminta LLM memanggil fungsi atau API eksternal agar dapat berinteraksi dengan sistem dunia nyata. Kamu berlatih AI Prompt Engineering dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai AI Prompt Engineering?

Tidak diperlukan pengalaman sebelumnya. AI Prompt Engineering di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 3.

Berapa lama pelajaran “Pemanggilan Fungsi dan Integrasi API” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Prompt Engineering ini?

Ya. Setiap pelajaran AI Prompt Engineering menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke AI Prompt Engineering