Ferramentas

Aprenda como conectar LLMs a ferramentas externas.

Introdução

Através da funcionalidade tools, você pode fazer com que seu modelo utilize ferramentas externas.

Assim como a API de Chamada de Função da OpenAI <https://platform.openai.com/docs/guides/function-calling>_, você pode definir funções com parâmetros e fazer com que o modelo selecione dinamicamente qual função chamar e quais argumentos passar para ela.

Este é o processo geral de chamada de funções:

1. Você submete uma consulta, detalhando as funções, seus parâmetros e descrições.

2. O LLM decide se deve ativar a funcionalidade. Se optar por não ativar, ele responde em linguagem cotidiana, fornecendo uma solução com base em seu entendimento interno ou solicitando mais detalhes sobre a consulta e o uso das ferramentas. Ao decidir usar as ferramentas, ele recomenda APIs adequadas e instruções de uso no formato JSON.

3. Em seguida, você implementa a chamada de API no aplicativo, envia a resposta retornada de volta ao LLM para análise dos resultados e prossegue com a próxima etapa.

Atualmente, não há um endpoint de API dedicado implementado para a funcionalidade tools. Ele deve ser utilizado em conjunto com a API de Chat.

Lista de modelos suportados

Xinference suporta que os seguintes modelos utilizem a funcionalidade tools:

• glm4-chat

• glm4-chat-1m

• llama-3.1-instruct

• llama-3.3-instruct

• qwen1.5-chat

• qwen1.5-moe-chat

• qwen2-instruct

• qwen2-moe-instruct

• qwen2.5-instruct

• qwen2.5-coder-instruct

• QwQ-32B

• qwen3

• Qwen3-Instruct

• Qwen3-Coder

• deepseek-v3

• deepseek-r1-0528

Início Rápido

O parâmetro opcional tools na API Chat pode ser usado para fornecer especificações de funções. Seu objetivo é permitir que o modelo gere parâmetros de função que estejam em conformidade com as especificações fornecidas.

Exemplo de uso do cliente OpenAI

import openai

client = openai.Client(
    api_key="cannot be empty",
    base_url="http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1"
)
response = client.chat.completions.create(
    model="<MODEL_UID>",
    messages=[{
        "role": "user",
        "content": "Call me an Uber ride type 'Plus' in Berkeley at zipcode 94704 in 10 minutes"
    }],
    tools=[
        {
            "type": "function",
            "function": {
                "name": "uber_ride",
                "description": "Find suitable ride for customers given the location, "
                "type of ride, and the amount of time the customer is "
                "willing to wait as parameters",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "loc": {
                            "type": "int",
                            "description": "Location of the starting place of the Uber ride",
                        },
                        "type": {
                            "type": "string",
                            "enum": ["plus", "comfort", "black"],
                            "description": "Types of Uber ride user is ordering",
                        },
                        "time": {
                            "type": "int",
                            "description": "The amount of time in minutes the customer is willing to wait",
                        },
                    },
                },
            },
        }
    ],
)
print(response.choices[0].message)

O resultado da saída é:

{
    "role": "assistant",
    "content": null,
    "tool_calls": [
        "id": "call_ad2f383f-31c7-47d9-87b7-3abe928e629c",
        "type": "function",
        "function": {
            "name": "uber_ride",
            "arguments": "{\"loc\": 94704, \"type\": \"plus\", \"time\": 10}"
        }
    ],
}

Exemplo de uso do cliente Anthropic

import anthropic
import json
import uuid

client = anthropic.Anthropic(
    api_key="cannot be empty",
    base_url="http://localhost:9997"
)

response = client.messages.create(
    model="qwen3",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "What's the weather like in Beijing?"
        }
    ],
    tools=[
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Get weather information for a city",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {
                            "type": "string",
                            "description": "The city name",
                        },
                    },
                    "required": ["city"]
                },
            },
        }
    ],
    tool_choice={"type": "auto"}
)

O resultado da saída é:

{
    "role": "assistant",
    "content": null,
    "tool_calls": [
        "id": "call_26884d11-ff6b-48fb-ada7-734f3fd0dfcc",
        "type": "function",
        "function": {
            "name": "get_weather",
            "arguments": "{\"city\": \"Beijing\"}"
        }
    ],
}

Nota

Se o LLM usar chamadas de ferramenta, o motivo da conclusão será tool_calls. Caso contrário, será o motivo de conclusão padrão.

Nota

A API em si não executa nenhuma chamada de função. Os desenvolvedores precisam usar a saída do modelo para executar as chamadas de função.

Você pode encontrar mais exemplos sobre as capacidades de tools no tutorial de notebooks.

Chamada de função

Aprenda com um exemplo completo que demonstra o processo de chamada de função.

https://github.com/xorbitsai/inference/blob/main/examples/FunctionCall.ipynb