Blog
Bakış Açısı

Ollama ile Akış Yanıtları ve Araç Çağırma Nasıl Kullanılır

Bu rehber, Ollama'nın yeni özelliklerini (akış ve araç çağırma) kullanarak canlı sohbet uygulamaları oluşturmayı öğretir.

Efe Demir

Efe Demir

5 June 2025

Ollama ile Akış Yanıtları ve Araç Çağırma Nasıl Kullanılır

Bu kılavuz, Ollama'nın yeni ve güçlü özelliklerinden birini nasıl kullanacağınızı size adım adım anlatacaktır: yanıtları akış halinde sunma ve araçları (fonksiyonlar veya API'ler gibi) gerçek zamanlı olarak çağırma yeteneği. Bu, canlı hissettiren ve etraflarındaki dünyayla etkileşime girebilen sohbet uygulamaları oluşturmak için çığır açan bir özelliktir.

Bu eğitimde öğrenecekleriniz:

💡
Harika bir API Test aracı mı arıyorsunuz? Harika API Dokümantasyonu oluşturur?

Geliştirici Ekibinizin maksimum verimlilikle birlikte çalışması için entegre, Hepsi Bir Arada bir platform mu istiyorsunuz?

Apidog tüm taleplerinizi karşılıyor ve Postman'in yerini çok daha uygun bir fiyata alıyor!
button

Başlarken: İhtiyacınız Olanlar

Eğitimi takip etmek için birkaç şeye ihtiyacınız olacak:

Temel Fikirleri Anlamak: Akış ve Araç Çağrıları

"Akış yanıtları" ve "araç çağırma" ile ne kastettiğimizi açıklayalım.

Yanıt Akışı Nedir?

Bir yapay zeka ile sohbet ettiğinizi hayal edin. Yapay zekanın düşünmesini ve tüm cevabını yazmasını beklemek yerine, akış, yapay zeka yanıtını parça parça, kelime kelime, oluşturdukça size gönderir. Bu, etkileşimin gerçek bir konuşma gibi çok daha hızlı ve daha doğal hissetmesini sağlar.

Ollama ile, akışı etkinleştirdiğinizde ("stream": true), bu artımlı güncellemeleri alırsınız.

Araç Çağırma Nasıl Çalışır?

Araç çağırma, yapay zeka modellerinizin sadece metin üretmekten daha fazlasını yapmasını sağlar. Yapay zekanın bilgi almak veya eylemler gerçekleştirmek için kullanmaya karar verebileceği "araçlar" - esasen fonksiyonlar veya harici API'ler - tanımlayabilirsiniz.

Örneğin, bir araç şunlar olabilir:

Bu araçları Ollama'ya tanımlarsınız ve yapay zeka bir aracı kullanmanın kullanıcının sorgusunu yanıtlamaya yardımcı olacağına karar verdiğinde, o aracı belirli argümanlarla çağırma niyetini sinyalleştirir. Uygulamanız daha sonra aracı çalıştırır ve sonuçları yapay zekaya geri göndererek konuşmaya devam edebilir.

Akışı Araç Çağırmayla Neden Birleştirmeli?

Ollama'nın büyük yükseltmesi, artık araç çağırmayı akış yanıtları sırasında işleyebilmesidir. Bu, uygulamanızın şunları yapabileceği anlamına gelir:

  1. Modelden ilk metni alın (akış halinde).
  2. Aniden, akış bir araç çağrısının gerekli olduğunu gösterebilir.
  3. Uygulamanız araç çağrısını işler.
  4. Bu arada, model daha fazla metin akışı yapabilir (örneğin, "Tamam, sizin için hava durumunu alacağım...").
  5. Uygulamanız aracın sonucunu aldıktan sonra, bunu modele geri gönderebilirsiniz ve araç çıktısından haberdar olarak yanıtını akış halinde sunmaya devam edecektir.

Bu, son derece duyarlı ve yetenekli yapay zeka uygulamaları oluşturur.

Bu Özellikleri Hangi Modeller Destekler?

Ollama bunu, şunlar dahil olmak üzere birçok popüler model için etkinleştirdi:

cURL ile İlk Akış Araç Çağrınızı Nasıl Yaparsınız?

cURL, Ollama'nın API'sini hızlıca test etmek için harika bir yoldur. Toronto'daki hava durumunu soralım.

Adım 1: Aracınızı Kavramsallaştırma

Aracımız get_current_weather olacak. Şunlara ihtiyacı var:

Adım 2: cURL Komutunu Oluşturma

Terminalinizi açın ve aşağıdaki komutu hazırlayın. Bunu parçalayacağız:

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"]
        }
      }
    }
  ]
}'

Parçalama:

Adım 3: Çıktıyı Yürütme ve Gözlemleme

Enter'a basın. Birbiri ardına görünen bir dizi JSON nesnesi göreceksiniz. Bu akış!

Akıştan örnek parçacıklar:

{
  "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, dahili sürecine bağlı olarak <think>...celsius...</think> gibi bazı "düşünme" belirteçleri çıkarabilir, bunlar da akışın bir parçasıdır)

Ardından, kritik olarak, şuna benzer bir şey görebilirsiniz:

{
  "model": "qwen3",
  "created_at": "2025-05-27T22:54:58.100509Z",
  "message": {
    "role": "assistant",
    "content": "", // Content might be empty when a tool call is made
    "tool_calls": [
      {
        "function": {
          "name": "get_current_weather",
          "arguments": { // The arguments the model decided on!
            "format": "celsius",
            "location": "Toronto"
          }
        }
      }
    ]
  },
  "done": false // Still not done, awaiting tool result
}

Neye Dikkat Etmeli:

Gerçek bir uygulamada, bir tool_calls parçası gördüğünüzde, kodunuz şunları yapacaktır:

  1. Akışın işlenmesini duraklatın (veya eşzamansız olarak işleyin).
  2. Gerçek get_current_weather fonksiyonunu/API'sini "Toronto" ve "celsius" ile çalıştırın.
  3. Sonucu alın (örneğin, "20 derece Celsius").
  4. Bu sonucu Ollama'ya role: "tool" ile yeni bir mesajda geri gönderin.
  5. Model daha sonra bu bilgiyi kullanarak yanıtını, aynı zamanda akış halinde, oluşturmaya devam edecektir.

Python Kullanarak Araç Çağrılarını Nasıl Akış Halinde Sunarsınız?

Ollama'nın resmi kitaplığını kullanarak benzer bir fikri Python'da uygulayalım.

Adım 1: Ollama Python Kütüphanesini Yükleme

Henüz yapmadıysanız, kitaplığı yükleyin veya yükseltin:

pip install -U ollama

Adım 2: Aracınızı Tanımlama ve Python'da Kodlama

Ollama Python SDK'sı, Python fonksiyonlarını doğrudan araç olarak geçirmenize olanak tanır. Yapay zeka için şemayı oluşturmak üzere fonksiyon imzasını ve docstring'i inceler.

Basit bir matematik aracı örneği oluşturalım (girdi add_two_numbers kullanır, ancak çıktı örneği model tarafından çağrılan subtract_two_numbers'ı gösterir. Tanım için sağlanan add_two_numbers'a bağlı kalacağız ve modelin isteme göre ne yapacağına karar vermesine izin vereceğiz.)

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.")

Python Kodunun Açıklaması:

  1. ollama'yı içe aktar.
  2. add_two_numbers fonksiyonu: Bu bizim aracımız. Docstring ve tür ipuçları, Ollama'nın amacını ve parametrelerini anlamasına yardımcı olur.
  3. messages: Konuşmaya kullanıcının sorgusuyla başlarız.
  4. ollama.chat(...):
  1. response_stream üzerinden döngü:
  1. Araç Çağrısını İşleme:

Beklenen Çıktı Akışı: İlk kullanıcı sorusunu, ardından asistanın yanıtının akış halinde sunulmasını göreceksiniz. add_two_numbers'ı (veya orijinal materyalin örnek çıktısındaki gibi, istem çıkarma içinse subtract_two_numbers'ı) çağırmaya karar verirse, "Araç Çağrısı Algılandı" mesajını, argümanları, Python fonksiyonunuzun sonucunu ve ardından asistanın bu sonucu kullanarak yanıtına devam ettiğini göreceksiniz.

(Orijinal örnek çıktı şunu gösteriyordu:

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

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

Bu, yapay zekanın dahili "düşünce" sürecini ve ardından Python SDK'sının sağladığı yapılandırılmış araç çağrısı nesnesini gösterir.)

JavaScript (Node.js) Kullanarak Araç Çağrılarını Nasıl Akış Halinde Sunarsınız?

Şimdi, genellikle bir Node.js arka ucu veya web uygulaması için aynı şeyi JavaScript ile yapalım.

Adım 1: Ollama JavaScript Kütüphanesini Yükleme

Proje dizininizde şunu çalıştırın:

npm i ollama

Adım 2: Araç Şemasını Tanımlama ve JavaScript'te Kodlama

JavaScript'te, genellikle araç şemasını bir JSON nesnesi olarak tanımlarsınız.

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);

JavaScript Kodunun Açıklaması:

  1. ollama'yı içe aktar.
  2. addTool nesnesi: Bu, aracımızı Ollama'ya açıklayan JSON şemasıdır.
  3. executeAddTwoNumbers fonksiyonu: Aracımız için gerçek JavaScript fonksiyonumuz.
  4. main async fonksiyonu:
  1. Araç Çağrısını İşleme: Python'a benzer şekilde, toolToCallInfo ayarlanırsa:

Beklenen Çıktı Akışı (cURL ve Python örneklerine benzer): Kullanıcının sorusunu, ardından asistanın yanıtının akışını göreceksiniz. addTwoNumbers'ı çağırmaya karar verdiğinde, araç çağrısı bilgilerini, JavaScript fonksiyonunuzdan gelen sonucu yazdıracak ve ardından yapay zekanın o sonuca dayalı olarak yanıtını akış halinde sunmaya devam edecektir.

JS için orijinal örnek çıktı şöyle görünüyordu:

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

Ollama, Akış Sırasında Araç Ayrıştırmayı Nasıl İşler?

Ollama'nın metni nasıl akış halinde sunduğunu ve araç çağrılarını bu kadar sorunsuz bir şekilde nasıl tanımladığını merak edebilirsiniz. Akıllıca yeni bir artımlı ayrıştırıcı kullanır.

Bu neden daha iyi?

İpucu: Bağlam Penceresi ile Performansı İyileştirme

Daha karmaşık etkileşimler için, özellikle araç çağırma ile, modelin kullandığı "bağlam penceresinin" boyutu önemli olabilir. Daha büyük bir bağlam penceresi, modelin mevcut konuşmanın daha fazlasını hatırlaması anlamına gelir.

Örnek: cURL ile Bağlam Penceresi Ayarlama(Orijinal materyalde önerildiği gibi llama3.1 veya llama4 gibi daha büyük bağlamları destekleyen bir model kullanın - ancak örnek llama3.2 kullanır)

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
  }
}'

Araç çağırmanın istediğiniz kadar güvenilir olmadığını fark ederseniz bu ayarla deney yapın.

Buradan Nereye Gidilir?

Artık, akış yanıtları ve araç

Explore more

Fathom-R1-14B: Hindistan'dan Gelişmiş Yapay Zeka Muhakeme Modeli

Fathom-R1-14B: Hindistan'dan Gelişmiş Yapay Zeka Muhakeme Modeli

Yapay zeka hızla gelişiyor. FractalAIResearch/Fathom-R1-14B, 14.8 milyar parametreyle matematik ve genel akıl yürütmede başarılı.

5 June 2025

Mistral Code: İşletmeler için En Özelleştirilebilir Yapay Zeka Destekli Kodlama Asistanı

Mistral Code: İşletmeler için En Özelleştirilebilir Yapay Zeka Destekli Kodlama Asistanı

Mistral Code'u keşfedin: Kurumsal kullanıma özel, en özelleştirilebilir yapay zeka destekli kodlama asistanı.

5 June 2025

Claude Code'un 2025'te Yapay Zeka Kodlamasını Nasıl Dönüştürdüğü

Claude Code'un 2025'te Yapay Zeka Kodlamasını Nasıl Dönüştürdüğü

Claude Code, 2025'te yapay zeka destekli kodlamayı nasıl devrimleştiriyor? Özelliklerini, kullanımını ve Windsurf kısıtlamalarından sonra neden popüler olduğunu öğrenin. Geliştiriciler için okunması gereken!

5 June 2025

API Tasarım-Öncelikli Yaklaşımı Apidog'da Uygulayın

API'leri oluşturmanın ve kullanmanın daha kolay yolunu keşfedin

Ücretsiz Kaydolİndir