Cara Menggunakan Ollama untuk Streaming Respons dan Pemanggilan Alat

Panduan ini akan memandu Anda menggunakan salah satu fitur baru Ollama yang canggih: kemampuan untuk melakukan *streaming* respons dan memanggil *tools* (seperti fungsi atau API) secara *real-time*. Ini adalah terobosan besar untuk membangun aplikasi obrolan yang terasa hidup dan dapat berinteraksi dengan dunia di sekitarnya.

Apa yang akan Anda pelajari dalam tutorial ini:

Apa arti *streaming* respons dan pemanggilan *tool* di Ollama.
Mengapa kombinasi ini sangat berguna untuk proyek AI Anda.
Instruksi langkah demi langkah untuk mengimplementasikannya menggunakan:
cURL (untuk pengujian cepat dan akses universal)
Python (untuk aplikasi *backend*)
JavaScript (untuk aplikasi web dan Node.js)
Sekilas tentang bagaimana Ollama dengan cerdas menangani fitur-fitur ini.
Tips untuk mendapatkan kinerja terbaik.

💡

Ingin alat Pengujian API yang hebat yang menghasilkan Dokumentasi API yang indah?

Ingin platform All-in-One yang terintegrasi untuk Tim Pengembang Anda bekerja sama dengan produktivitas maksimum?

Apidog memenuhi semua kebutuhan Anda, dan menggantikan Postman dengan harga yang jauh lebih terjangkau!

button

Memulai: Apa yang Anda Butuhkan

Untuk mengikuti, Anda akan memerlukan beberapa hal:

Ollama Terinstal: Pastikan Anda memiliki versi terbaru Ollama yang berjalan di sistem Anda. Jika belum, kunjungi situs web resmi Ollama untuk mengunduh dan menginstalnya.
Pengetahuan Dasar Command-Line: Untuk contoh cURL.
Lingkungan Python (untuk bagian Python): Python 3.x terinstal, bersama dengan pip untuk mengelola paket.
Lingkungan Node.js (untuk bagian JavaScript): Node.js dan npm terinstal.
Pemahaman tentang JSON: Ollama menggunakan JSON untuk menyusun data dan pemanggilan *tool*.

Memahami Ide Utama: Streaming dan Pemanggilan Tool

Mari kita bedah apa yang kita maksud dengan "*streaming* respons" dan "pemanggilan *tool*."

Apa Itu Streaming Respons?

Bayangkan Anda sedang mengobrol dengan AI. Alih-alih menunggu AI berpikir dan mengetik seluruh jawabannya sebelum Anda melihat apa pun, *streaming* berarti AI mengirimkan responsnya kepada Anda sepotong demi sepotong, kata demi kata, saat AI menghasilkannya. Ini membuat interaksi terasa jauh lebih cepat dan lebih alami, seperti percakapan nyata.

Dengan Ollama, ketika Anda mengaktifkan *streaming* ("stream": true), Anda mendapatkan pembaruan inkremental ini.

Bagaimana Pemanggilan Tool Bekerja?

Pemanggilan *tool* memungkinkan model AI Anda melakukan lebih dari sekadar menghasilkan teks. Anda dapat mendefinisikan "*tools*" – yang pada dasarnya adalah fungsi atau API eksternal – yang dapat diputuskan oleh AI untuk digunakan guna mendapatkan informasi atau melakukan tindakan.

Misalnya, *tool* bisa berupa:

get_current_weather(location): Mengambil cuaca saat ini.
calculate_sum(number1, number2): Melakukan perhitungan.
search_web(query): Mendapatkan informasi dari internet.

Anda mendeskripsikan *tools* ini kepada Ollama, dan ketika AI menentukan bahwa menggunakan *tool* akan membantu menjawab pertanyaan pengguna, AI akan memberi sinyal niatnya untuk memanggil *tool* tersebut dengan argumen spesifik. Aplikasi Anda kemudian mengeksekusi *tool* tersebut dan dapat mengirimkan hasilnya kembali ke AI untuk melanjutkan percakapan.

Mengapa Menggabungkan Streaming dengan Pemanggilan Tool?

Peningkatan besar Ollama adalah kemampuannya menangani pemanggilan *tool* selama melakukan *streaming* respons. Ini berarti aplikasi Anda dapat:

Menerima teks awal dari model (*streamed*).
Tiba-tiba, *stream* mungkin mengindikasikan bahwa pemanggilan *tool* diperlukan.
Aplikasi Anda memproses pemanggilan *tool*.
Sementara itu, model bahkan mungkin melakukan *streaming* lebih banyak teks (misalnya, "Oke, saya akan mengambilkan cuaca untuk Anda...").
Setelah aplikasi Anda mendapatkan hasil *tool*, Anda dapat mengirimkannya kembali ke model, dan model akan terus melakukan *streaming* responsnya, yang sekarang diinformasikan oleh keluaran *tool*.

Ini menciptakan aplikasi AI yang sangat responsif dan mampu.

Model Mana yang Mendukung Fitur Ini?

Ollama telah mengaktifkan ini untuk beberapa model populer, termasuk:

Qwen 3
Devstral
Qwen2.5 dan Qwen2.5-coder
Llama 3.1
Llama 4
...dan lebih banyak lagi yang terus ditambahkan!

Cara Melakukan Pemanggilan Tool Streaming Pertama Anda dengan cURL

cURL adalah cara yang bagus untuk menguji API Ollama dengan cepat. Mari kita tanyakan cuaca di Toronto.

Langkah 1: Mengkonseptualisasikan Tool Anda

*Tool* kita akan menjadi get_current_weather. Ini membutuhkan:

location (string): mis., "Toronto"
format (string): mis., "celsius" atau "fahrenheit"

Langkah 2: Membuat Perintah cURL

Buka terminal Anda dan siapkan perintah berikut. Kita akan memecahnya:

curl <http://localhost:11434/api/chat> -d '{
  "model": "qwen3",
  "messages": [
    {
      "role": "user",
      "content": "What is the weather today in Toronto?"
    }
  ],
  "stream": true,
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_current_weather",
        "description": "Get the current weather for a location",
        "parameters": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The location to get the weather for, e.g. San Francisco, CA"
            },
            "format": {
              "type": "string",
              "description": "The format to return the weather in, e.g. \\\\\\\\'celsius\\\\\\\\' or \\\\\\\\'fahrenheit\\\\\\\\'",
              "enum": ["celsius", "fahrenheit"]
            }
          },
          "required": ["location", "format"]
        }
      }
    }
  ]
}'

Penjelasan:

curl <http://localhost:11434/api/chat:> Perintah dan titik akhir API obrolan Ollama.
d '{...}': Mengirim data JSON dalam badan permintaan (*request body*).
"model": "qwen3": Menentukan model AI mana yang akan digunakan.
"messages": [...]: Riwayat percakapan. Di sini, hanya pertanyaan pengguna.
"stream": true: Ini kuncinya! Ini memberitahu Ollama untuk melakukan *streaming* respons.
"tools": [...]: Sebuah array tempat kita mendefinisikan *tools* yang tersedia untuk model.
"type": "function": Menentukan jenis *tool*.
"function": {...}: Mendeskripsikan fungsi.
"name": "get_current_weather": Nama *tool*.
"description": "...": Membantu model memahami apa yang dilakukan *tool*.
"parameters": {...}: Mendefinisikan argumen yang diterima *tool* (menggunakan JSON Schema).

Langkah 3: Eksekusi dan Amati Keluaran

Tekan Enter. Anda akan melihat serangkaian objek JSON muncul satu demi satu. Ini adalah *stream*!

Contoh cuplikan dari *stream*:

{
  "model": "qwen3", "created_at": "...",
  "message": { "role": "assistant", "content": "Okay, " }, "done": false
}

{
  "model": "qwen3", "created_at": "...",
  "message": { "role": "assistant", "content": "I will " }, "done": false
}

{
  "model": "qwen3", "created_at": "...",
  "message": { "role": "assistant", "content": "try to get that for you." }, "done": false
}

(Model mungkin mengeluarkan beberapa token "berpikir" seperti <think>...celsius...</think> tergantung pada proses internalnya, ini juga merupakan bagian dari *stream*)

Kemudian, yang penting, Anda mungkin melihat sesuatu seperti ini:

{
  "model": "qwen3",
  "created_at": "2025-05-27T22:54:58.100509Z",
  "message": {
    "role": "assistant",
    "content": "", // Konten mungkin kosong saat pemanggilan tool dilakukan
    "tool_calls": [
      {
        "function": {
          "name": "get_current_weather",
          "arguments": { // Argumen yang diputuskan oleh model!
            "format": "celsius",
            "location": "Toronto"
          }
        }
      }
    ]
  },
  "done": false // Masih belum selesai, menunggu hasil tool
}

Apa yang Perlu Diperhatikan:

Setiap bagian adalah objek JSON.
"done": false berarti *stream* sedang berlangsung. Bagian terakhir akan memiliki "done": true.
Objek "message" berisi:
"role": "assistant"
"content": Bagian teks dari *stream*.
"tool_calls": Sebuah array yang muncul ketika model ingin menggunakan *tool*. Ini mencakup name *tool* dan arguments yang diputuskan.

Dalam aplikasi nyata, ketika Anda melihat bagian tool_calls, kode Anda akan:

Menjeda pemrosesan *stream* (atau menanganinya secara asinkron).
Mengeksekusi fungsi/API get_current_weather yang sebenarnya dengan "Toronto" dan "celsius".
Mendapatkan hasilnya (misalnya, "20 derajat Celcius").
Mengirimkan hasil ini kembali ke Ollama dalam pesan baru dengan role: "tool".
Model kemudian akan menggunakan informasi ini untuk terus menghasilkan responsnya, juga di-*stream*.

Cara Melakukan Streaming Pemanggilan Tool Menggunakan Python

Mari kita implementasikan ide serupa di Python menggunakan pustaka resmi Ollama.

Langkah 1: Menginstal Pustaka Python Ollama

Jika Anda belum melakukannya, instal atau tingkatkan pustakanya:

pip install -U ollama

Langkah 2: Mendefinisikan Tool Anda dan Melakukan Coding di Python

Ollama Python SDK dengan cerdas memungkinkan Anda meneruskan fungsi Python secara langsung sebagai *tools*. Ini memeriksa tanda tangan fungsi dan *docstring* untuk membuat skema untuk AI.

Mari kita buat contoh *tool* matematika sederhana (input menggunakan add_two_numbers tetapi contoh output menunjukkan subtract_two_numbers dipanggil oleh model. Kita akan tetap menggunakan add_two_numbers yang disediakan untuk definisi dan membiarkan model memutuskan apa yang harus dilakukan berdasarkan *prompt*.)

import ollama

# Define the python function that can be used as a tool
def add_two_numbers(a: int, b: int) -> int:
  """
  Add two numbers.

  Args:
    a (int): The first number as an int.
    b (int): The second number as an int.

  Returns:
    int: The sum of the two numbers.
  """
  print(f"--- Tool 'add_two_numbers' called with a={a}, b={b} ---")
  return a + b

# --- Main conversation logic ---
messages = [{'role': 'user', 'content': 'What is three plus one?'}]
# Or, for the subtraction example in the original output:
# messages = [{'role': 'user', 'content': 'what is three minus one?'}]

print(f"User: {messages[0]['content']}")

# Make the chat request with streaming and the tool
# Note: ChatResponse type hint might be ollama.ChatResponse or similar depending on library version
response_stream = ollama.chat(
  model='qwen3', # Or another capable model
  messages=messages,
  tools=[
      { # You can also define the tool explicitly if needed, or pass the function directly
          'type': 'function',
          'function': {
              'name': 'add_two_numbers', # Must match the Python function name if you want it to be called directly by your code later
              'description': 'Add two integer numbers together.',
              'parameters': {
                  'type': 'object',
                  'properties': {
                      'a': {'type': 'integer', 'description': 'The first number'},
                      'b': {'type': 'integer', 'description': 'The second number'}
                  },
                  'required': ['a', 'b']
              }
          }
      }
      # Simpler way for Python: pass the function directly if the library supports easy schema generation from it
      # tools=[add_two_numbers] # The SDK can often create the schema from this
  ],
  stream=True
)

print("Assistant (streaming):")
full_response_content = ""
tool_call_info = None

for chunk in response_stream:
  # Print the streamed content part
  if chunk['message']['content']:
    print(chunk['message']['content'], end='', flush=True)
    full_response_content += chunk['message']['content']

  # Check for tool calls in the chunk
  if 'tool_calls' in chunk['message'] and chunk['message']['tool_calls']:
    tool_call_info = chunk['message']['tool_calls'][0] # Assuming one tool call for simplicity
    print(f"\\\\n--- Detected Tool Call: {tool_call_info['function']['name']} ---")
    break # Stop processing stream for now, handle tool call

  if chunk.get('done'):
      print("\\\\n--- Stream finished ---")
      if not tool_call_info:
          print("No tool call was made.")

# --- If a tool call was detected, handle it ---
if tool_call_info:
  tool_name = tool_call_info['function']['name']
  tool_args = tool_call_info['function']['arguments']

  print(f"Arguments for the tool: {tool_args}")

  # Here, you'd actually call your Python tool function
  if tool_name == "add_two_numbers":
    # For safety, ensure arguments are of correct type if necessary
    try:
        arg_a = int(tool_args.get('a'))
        arg_b = int(tool_args.get('b'))
        tool_result = add_two_numbers(a=arg_a, b=arg_b)
        print(f"--- Tool execution result: {tool_result} ---")

        # Now, send this result back to Ollama to continue the conversation
        messages.append({'role': 'assistant', 'content': full_response_content, 'tool_calls': [tool_call_info]})
        messages.append({
            'role': 'tool',
            'content': str(tool_result), # Result must be a string
            'tool_call_id': tool_call_info.get('id', '') # If your library/model provides a tool_call_id
        })

        print("\\\\n--- Sending tool result back to model ---")

        follow_up_response_stream = ollama.chat(
            model='qwen3',
            messages=messages,
            stream=True
            # No tools needed here unless you expect another tool call
        )

        print("Assistant (after tool call):")
        for follow_up_chunk in follow_up_response_stream:
            if follow_up_chunk['message']['content']:
                print(follow_up_chunk['message']['content'], end='', flush=True)
            if follow_up_chunk.get('done'):
                print("\\\\n--- Follow-up stream finished ---")
                break
    except ValueError:
        print("Error: Could not parse tool arguments as integers.")
    except Exception as e:
        print(f"An error occurred during tool execution or follow-up: {e}")
  else:
    print(f"Error: Unknown tool '{tool_name}' requested by the model.")

Penjelasan Kode Python:

Impor ollama.
Fungsi add_two_numbers: Ini adalah *tool* kita. *Docstring* dan petunjuk tipe (*type hints*) membantu Ollama memahami tujuan dan parameternya.
messages: Kita memulai percakapan dengan pertanyaan pengguna.
ollama.chat(...):

model, messages, stream=True serupa dengan cURL.
tools=[...]: Kita menyediakan definisi *tool*. Python SDK cukup fleksibel; Anda dapat meneruskan objek fungsi secara langsung (misalnya, tools=[add_two_numbers]) jika dapat menyimpulkan skemanya, atau mendefinisikannya secara eksplisit seperti yang ditunjukkan.

Mengulang melalui response_stream:

chunk['message']['content']: Ini adalah teks yang di-*stream*. Kita mencetaknya segera.
chunk['message']['tool_calls']: Jika kunci ini ada dan memiliki konten, AI ingin menggunakan *tool*. Kita menyimpan tool_call_info ini dan menghentikan perulangan untuk menanganinya.

Menangani Pemanggilan Tool:

Kita mengekstrak tool_name dan tool_args.
Kita memanggil fungsi Python kita yang sebenarnya (add_two_numbers) dengan argumen ini.
Penting: Kita kemudian menambahkan respons parsial asisten (yang mengarah pada pemanggilan *tool*) dan pesan baru dengan role: "tool" dan content sebagai hasil fungsi kita yang di-*string*-kan ke daftar messages.
Kita melakukan panggilan ollama.chat lain dengan pesan-pesan yang diperbarui ini untuk mendapatkan respons akhir AI berdasarkan keluaran *tool*.

Alur Keluaran yang Diharapkan:Anda akan melihat pertanyaan awal pengguna, lalu respons asisten yang di-*streaming*. Jika memutuskan untuk memanggil add_two_numbers (atau subtract_two_numbers seperti dalam contoh output materi asli jika *prompt* untuk pengurangan), Anda akan melihat pesan "Detected Tool Call", argumen, hasil fungsi Python Anda, dan kemudian asisten melanjutkan responsnya menggunakan hasil tersebut.

(Contoh output asli menunjukkan:

<think>
Okay, the user is asking ...
</think>

[ToolCall(function=Function(name='subtract_two_numbers', arguments={'a': 3, 'b': 1}))]

Ini menunjukkan proses "pemikiran" internal AI dan kemudian objek pemanggilan *tool* terstruktur yang disediakan oleh Python SDK.)

Cara Melakukan Streaming Pemanggilan Tool Menggunakan JavaScript (Node.js)

Sekarang, mari kita lakukan hal yang sama dengan JavaScript, biasanya untuk *backend* Node.js atau aplikasi web.

Langkah 1: Menginstal Pustaka JavaScript Ollama

Di direktori proyek Anda, jalankan:

npm i ollama

Langkah 2: Mendefinisikan Skema Tool dan Melakukan Coding di JavaScript

Di JavaScript, Anda biasanya mendefinisikan skema *tool* sebagai objek JSON.

import ollama from 'ollama';

// Describe the tool schema (e.g., for adding two numbers)
const addTool = {
    type: 'function',
    function: {
        name: 'addTwoNumbers',
        description: 'Add two numbers together',
        parameters: {
            type: 'object',
            required: ['a', 'b'],
            properties: {
                a: { type: 'number', description: 'The first number' },
                b: { type: 'number', description: 'The second number' }
            }
        }
    }
};

// Your actual JavaScript function that implements the tool
function executeAddTwoNumbers(a, b) {
    console.log(`--- Tool 'addTwoNumbers' called with a=${a}, b=${b} ---`);
    return a + b;
}

async function main() {
    const messages = [{ role: 'user', content: 'What is 2 plus 3?' }];
    console.log('User:', messages[0].content);

    console.log('Assistant (streaming):');
    let assistantResponseContent = "";
    let toolToCallInfo = null;

    try {
        const responseStream = await ollama.chat({
            model: 'qwen3', // Or another capable model
            messages: messages,
            tools: [addTool],
            stream: true
        });

        for await (const chunk of responseStream) {
            if (chunk.message.content) {
                process.stdout.write(chunk.message.content);
                assistantResponseContent += chunk.message.content;
            }
            if (chunk.message.tool_calls && chunk.message.tool_calls.length > 0) {
                toolToCallInfo = chunk.message.tool_calls[0]; // Assuming one tool call
                process.stdout.write(`\\\\n--- Detected Tool Call: ${toolToCallInfo.function.name} ---\\\\n`);
                break; // Stop processing stream to handle tool call
            }
            if (chunk.done) {
                process.stdout.write('\\\\n--- Stream finished ---\\\\n');
                if (!toolToCallInfo) {
                    console.log("No tool call was made.");
                }
                break;
            }
        }

        // --- If a tool call was detected, handle it ---
        if (toolToCallInfo) {
            const toolName = toolToCallInfo.function.name;
            const toolArgs = toolToCallInfo.function.arguments;

            console.log(`Arguments for the tool:`, toolArgs);

            let toolResult;
            if (toolName === 'addTwoNumbers') {
                toolResult = executeAddTwoNumbers(toolArgs.a, toolArgs.b);
                console.log(`--- Tool execution result: ${toolResult} ---`);

                // Append assistant's partial message and the tool message
                messages.push({
                    role: 'assistant',
                    content: assistantResponseContent, // Include content leading up to tool call
                    tool_calls: [toolToCallInfo]
                });
                messages.push({
                    role: 'tool',
                    content: toolResult.toString(), // Result must be a string
                    // tool_call_id: toolToCallInfo.id // If available and needed
                });

                console.log("\\\\n--- Sending tool result back to model ---");
                const followUpStream = await ollama.chat({
                    model: 'qwen3',
                    messages: messages,
                    stream: true
                });

                console.log("Assistant (after tool call):");
                for await (const followUpChunk of followUpStream) {
                    if (followUpChunk.message.content) {
                        process.stdout.write(followUpChunk.message.content);
                    }
                     if (followUpChunk.done) {
                        process.stdout.write('\\\\n--- Follow-up stream finished ---\\\\n');
                        break;
                    }
                }
            } else {
                console.error(`Error: Unknown tool '${toolName}' requested.`);
            }
        }

    } catch (error) {
        console.error('Error during Ollama chat:', error);
    }
}

main().catch(console.error);

Penjelasan Kode JavaScript:

Impor ollama.
Objek addTool: Ini adalah skema JSON yang mendeskripsikan *tool* kita ke Ollama.
Fungsi executeAddTwoNumbers: Fungsi JavaScript kita yang sebenarnya untuk *tool*.
Fungsi main async:

Array messages memulai percakapan.
await ollama.chat({...}): Melakukan panggilan.
tools: [addTool]: Meneruskan skema *tool* kita.
stream: true: Mengaktifkan *streaming*.
for await (const chunk of responseStream): Perulangan ini memproses setiap bagian yang di-*stream*.
chunk.message.content: Bagian teks dari *stream*.
chunk.message.tool_calls: Jika ada, AI ingin menggunakan *tool*. Kita menyimpan toolToCallInfo.

Menangani Pemanggilan Tool: Serupa dengan Python, jika toolToCallInfo diatur:

Ekstrak nama dan argumen.
Panggil executeAddTwoNumbers().
Tambahkan pesan asisten (yang menyertakan permintaan pemanggilan *tool*) dan pesan role: "tool" baru dengan hasil ke array messages.
Lakukan panggilan ollama.chat lain dengan pesan-pesan yang diperbarui untuk mendapatkan respons akhir.

Alur Keluaran yang Diharapkan (serupa dengan contoh cURL dan Python):Anda akan melihat pertanyaan pengguna, lalu respons asisten yang di-*streaming*. Ketika memutuskan untuk memanggil addTwoNumbers, ia akan mencetak informasi pemanggilan *tool*, hasil dari fungsi JavaScript Anda, dan kemudian melanjutkan *streaming* jawaban AI berdasarkan hasil tersebut.

Contoh output asli untuk JS terlihat seperti:

Question: What is 2 plus 3?
<think>
Okay, the user is asking...
</think>
Tool call: {
  function: {
    name: "addTwoNumbers",
    arguments: { a: 2, b: 3 },
  },
}

Bagaimana Ollama Menangani Parsing Tool Selama Streaming

Anda mungkin bertanya-tanya bagaimana Ollama berhasil melakukan *streaming* teks dan mengidentifikasi pemanggilan *tool* dengan begitu lancar. Ini menggunakan parser inkremental baru yang cerdas.

Cara Lama: Banyak sistem harus menunggu seluruh respons AI, lalu memindainya untuk mencari pemanggilan *tool* (biasanya diformat sebagai JSON). Ini memblokir *streaming* karena pemanggilan *tool* dapat muncul di mana saja.
Cara Baru Ollama:
Parser melihat template spesifik setiap model untuk memahami bagaimana ia memberi sinyal pemanggilan *tool* (misalnya, token atau prefiks khusus).
Ini memungkinkan Ollama mengidentifikasi pemanggilan *tool* "secara inkremental" saat data masuk melalui *stream*, memisahkannya dari konten teks biasa.
Cukup cerdas untuk menangani model yang tidak secara eksplisit dilatih dengan prefiks *tool* tetapi masih berhasil menghasilkan struktur pemanggilan *tool* yang valid. Bahkan dapat kembali mencari struktur seperti JSON jika diperlukan, tetapi dengan cerdas, sehingga tidak hanya mengambil JSON apa pun.

Mengapa ini lebih baik?

Streaming Sejati: Anda mendapatkan teks segera, dan pemanggilan *tool* diidentifikasi dengan cepat.
Akurasi: Lebih baik dalam menghindari positif palsu (misalnya, jika AI membicarakan pemanggilan *tool* yang telah dilakukannya sebelumnya, parser baru cenderung tidak salah memicu kembali).

Tip: Meningkatkan Kinerja dengan Jendela Konteks

Untuk interaksi yang lebih kompleks, terutama dengan pemanggilan *tool*, ukuran "jendela konteks" yang digunakan model dapat menjadi penting. Jendela konteks yang lebih besar berarti model mengingat lebih banyak percakapan saat ini.

Model Context Protocol (MCP): Peningkatan Ollama bekerja dengan baik dengan MCP.
num_ctx: Anda sering dapat menyarankan ukuran jendela konteks. Misalnya, 32.000 (32k) token atau lebih tinggi dapat meningkatkan kinerja pemanggilan *tool* dan kualitas hasilnya.
Trade-off: Jendela konteks yang lebih besar menggunakan lebih banyak memori.

Contoh: Mengatur Jendela Konteks dengan cURL(Gunakan model yang mendukung konteks yang lebih besar, seperti llama3.1 atau llama4 seperti yang disarankan dalam materi asli - meskipun contoh menggunakan llama3.2)

curl -X POST "<http://localhost:11434/api/chat>" -d '{
  "model": "llama3.1",
  "messages": [
    {
      "role": "user",
      "content": "why is the sky blue?"
    }
  ],
  "options": {
    "num_ctx": 32000
  }
}'

Bereksperimenlah dengan pengaturan ini jika Anda merasa pemanggilan *tool* tidak seandal yang Anda inginkan.

Ke Mana Selanjutnya?

Anda sekarang memiliki dasar-dasar untuk membangun aplikasi AI yang canggih dan *real-time* dengan Ollama menggunakan *streaming* respons dan pemanggilan *tool*!

Ide untuk dieksplorasi:

Menghubungkan *tools* ke API dunia nyata (cuaca, saham, mesin pencari).
Membangun agen yang dapat melakukan tugas multi-langkah.
Membuat *chatbot* yang lebih alami dan responsif.

Lihat dokumentasi resmi Ollama dan repositori GitHub-nya (termasuk "Tool Streaming Pull Request" yang disebutkan dalam sumber asli untuk pembahasan teknis yang lebih mendalam) untuk pembaruan terbaru dan contoh yang lebih canggih.

💡

button