Compartilhar via

Integrar a chamada de ferramenta com a Inferência LLM usando o complemento do Operador de conjunto de ferramentas de IA no Serviço de Kubernetes do Azure (AKS)

Neste artigo, você configurará e implantará um workspace de inferência do Operador de conjunto de ferramentas de IA (KAITO) no Serviço de Kubernetes do Azure (AKS) com suporte para a chamada de ferramentas no estilo OpenAI. Você também aprenderá a validar a funcionalidade de chamada de ferramenta usando métricas vLLM e simulações de função local.

O que é invocação de ferramenta?

A chamada de ferramenta permite que LLMs (modelos de linguagem grandes) interajam com funções externas, APIs ou serviços. Em vez de apenas gerar texto, uma LLM pode decidir:

  • "Preciso chamar uma API meteorológica."
  • "Preciso usar uma calculadora."
  • "Devo pesquisar um banco de dados."

Ele faz isso invocando uma "ferramenta" definida com parâmetros escolhidos com base na solicitação do usuário. O uso de ferramentas é útil para:

  • Chatbots que reservam, resumem ou calculam.
  • Aplicativos LLM corporativos em que a alucinação deve ser minimizada.
  • Estruturas de agente (AutoGen, LangGraph, LangChain, AgentOps etc.).

Em ambientes de produção, os aplicativos habilitados para IA geralmente exigem mais do que a geração de linguagem natural; eles exigem a capacidade de executar ações com base na intenção do usuário. A chamada de ferramentas permite que os LLMs ampliem suas respostas além do texto, invocando ferramentas externas, APIs ou lógica personalizada em tempo real. Isso faz a ponte entre a compreensão e a execução da linguagem, permitindo que os desenvolvedores criem assistentes interativos de IA, agentes e fluxos de trabalho de automação que são precisos e úteis. Em vez de depender de respostas estáticas, as LLMs agora podem acessar dados dinâmicos, disparar serviços e concluir tarefas em nome dos usuários, de forma segura e confiável.

Quando implantada no AKS, a chamada de ferramenta se torna escalonável, segura e pronta para produção. O Kubernetes fornece a flexibilidade para orquestrar cargas de trabalho de inferência usando runtimes de alto desempenho, como vLLM, ao mesmo tempo em que garante a observabilidade e a governança do uso da ferramenta. Com esse padrão, os operadores do AKS e os desenvolvedores de aplicativos podem atualizar mais facilmente modelos ou ferramentas de forma independente e implantar recursos avançados de IA sem comprometer a confiabilidade.

Como resultado, o uso de ferramentas no AKS agora é um padrão fundamental para a criação de aplicativos de IA modernos que são sensíveis ao contexto, capazes de tomar ações e adequados para o ambiente empresarial.

Ativação de ferramenta com o KAITO

Para simplificar esse modelo de implantação, o complemento do Operador de conjunto de ferramentas de IA (KAITO) para AKS fornece uma solução gerenciada para executar serviços de inferência com o suporte de chamada de ferramenta. Ao aproveitar os espaços de trabalho de inferência KAITO, você pode rapidamente criar pontos finais de modelo escaláveis e acelerados por GPU com suporte integrado para a chamada de ferramentas e APIs compatíveis com o OpenAI. Isso elimina a sobrecarga operacional de configurar runtimes, gerenciar dependências ou dimensionar a infraestrutura manualmente.

Pré-requisitos

Confirme se o workspace de inferência KAITO está em execução

  • Monitore a implantação do seu workspace com o comando kubectl get.

    kubectl get workspace workspace‑phi‑4‑mini-toolcall -w

    Na saída, você quer verificar se o recurso (ResourceReady) e a inferência (InferenceReady) estão prontos e o workspace foi bem-sucedido (WorkspaceSucceeded sendo true).

Confirme se a API de inferência está pronta para ser fornecida

  1. Depois que o workspace estiver pronto, localize o endpoint de serviço usando o kubectl get comando.

    kubectl get svc workspace‑phi‑4-mini-toolcall

    Observação

    A saída pode ser um endereço ClusterIP ou um endereço interno. Verifique em quais portas o serviço está escutando. A API de inferência KAITO padrão está na porta 80 para HTTP. Se for apenas interno, você poderá redirecionar a porta localmente.

  2. Encaminhe o serviço de inferência para teste usando o kubectl port-forward comando.

    kubectl port-forward svc/workspace‑phi‑4‑mini-toolcall 8000:80

  3. Verifique o endpoint /v1/models para confirmar se o LLM está disponível usando curl.

    curl http://localhost:8000/v1/models

    Para garantir que o LLM esteja implantado e a API esteja funcionando, sua saída deve ser semelhante à seguinte:

    ...
{
  "object": "list",
  "data": [
    {
      "id": "phi‑4‑mini‑instruct",
      ...
      ...
    }
  ]
}
...

Testar a ferramenta de nomeação e de chamada de função

Neste exemplo, o workspace workspace‑phi‑4‑mini-toolcall dá suporte às chamadas de funções designadas por padrão, porque podemos confirmar que o LLM aceita um especificador de "ferramenta" em solicitações no formato OpenAI e retorna uma estrutura de "chamada de função".

O snippet do Python que usamos nesta seção é da documentação do KAITO e usa um cliente compatível com OpenAI.

  • Confirme se o LLM aceita uma especificação de “ferramenta” em solicitações no estilo OpenAI e retorna uma estrutura de “chamada de função”. Este exemplo:

    • Inicializa o cliente compatível com OpenAI para falar com um servidor de inferência local. Supõe-se que o servidor esteja em execução no http://localhost:8000/v1 e aceite chamadas à API ao estilo OpenAI.
    • Simula a lógica de back-end para uma ferramenta chamada get_weather. (Em um cenário real, isso chamaria uma API meteorológica.)
    • Descreve a interface da ferramenta; o Phi-4-mini LLM verá essa ferramenta e decidirá se a usará com base na entrada do usuário.
    • Envia uma mensagem de chat de exemplo para o modelo e fornece a especificação da ferramenta. A configuração tool_choice="auto" permite que o LLM decida se deve chamar uma ferramenta com base no prompt.
    • Nesse caso, a solicitação do usuário era relevante para a get_weather ferramenta, portanto, simulamos a execução da ferramenta, chamando a função local com os argumentos escolhidos do modelo.
    from openai import OpenAI
import json

# local server
client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")

def get_weather(location: str, unit: str) -> str:
    return f"Getting the weather for {location} in {unit}..."

tool_functions = {"get_weather": get_weather}

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {"type": "string"},
                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
            },
            "required": ["location", "unit"]
        }
    }
}]

response = client.chat.completions.create(
    model="phi‑4‑mini‑instruct",   # or client.models.list().data[0].id
    messages=[{"role": "user", "content": "What's the weather like in San Francisco?"}],
    tools=tools,
    tool_choice="auto"
)

# Inspect response
tool_call = response.choices[0].message.tool_calls[0].function
args = json.loads(tool_call.arguments)
print("Function called:", tool_call.name)
print("Arguments:", args)
print("Result:", tool_functions[tool_call.name](**args))

    Seu resultado deve ser semelhante ao seguinte:

    Function called: get_weather  
Arguments: {"location": "San Francisco, CA", "unit": "fahrenheit"}  
Result: Getting the weather for San Francisco, CA in fahrenheit...

    O campo "tool_calls" retorna, o que significa que o LLM Phi-4-mini decidiu invocar a função. Agora, uma chamada de ferramenta de exemplo foi analisada e executada com sucesso com base na decisão do modelo para confirmar o comportamento de chamada de ferramenta de ponta a ponta com a implantação de inferência KAITO.

Resolução de problemas

A predefinição de modelo não dá suporte à chamada de ferramenta

Se você escolher um modelo que não esteja na lista com suporte, a chamada de ferramenta poderá não funcionar. Examine a documentação do KAITO, que lista explicitamente quais predefinições dão suporte à chamada de ferramenta.

Runtime desalinhado

A inferência KAITO deve usar o runtime de vLLM para chamada de ferramenta (o runtime do HuggingFace Transformers geralmente não dá suporte à chamada de ferramenta no KAITO).

Problemas de rede/endpoint

Se estiver fazendo o encaminhamento de porta, certifique-se de que as portas de serviço estejam encaminhadas corretamente. Se o servidor MCP externo estiver inacessível, ocorrerá um erro.

Timeouts

Chamadas externas do servidor MCP podem levar tempo. Certifique-se de que o tempo limite do adaptador ou do cliente seja suficientemente alto.

Authentication

Se o servidor MCP externo exigir autenticação (chave de API, cabeçalho etc.), verifique se você fornece credenciais corretas.

Próximas etapas

  • Last updated on