Partilhar via

Integre chamadas de ferramentas com o LLM Inference com o complemento do operador da cadeia de ferramentas de IA no Serviço Kubernetes do Azure (AKS)

Neste artigo, você configura e implanta um espaço de trabalho de inferência do operador de cadeia de ferramentas de IA (KAITO) no Serviço Kubernetes do Azure (AKS) com suporte para chamadas de ferramentas no estilo OpenAI. Você também aprende como validar a funcionalidade de chamada de ferramenta usando métricas vLLM e simulações de função local.

O que é invocação de ferramentas?

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

  • "Preciso ligar para uma API meteorológica."
  • "Preciso usar uma calculadora."
  • "Devo pesquisar uma base de dados."

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

  • Chatbots que reservam, resumem ou calculam.
  • Aplicações LLM empresariais onde a alucinação deve ser minimizada.
  • Frameworks de agentes (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 agir com base na intenção do usuário. A chamada de ferramentas permite que os LLMs se estendam além das respostas de texto, invocando ferramentas externas, APIs ou lógica personalizada em tempo real. Isso preenche a lacuna entre a compreensão e a execução da linguagem, permitindo que os desenvolvedores criem assistentes de IA interativos, agentes e fluxos de trabalho de automação que sejam precisos e úteis. Em vez de depender de respostas estáticas, os LLMs agora podem acessar dados em tempo real, acionar serviços e concluir tarefas em nome dos usuários, de forma segura e confiável.

Quando implantada no AKS, a chamada de ferramentas torna-se escalável, segura e pronta para produção. O Kubernetes oferece a flexibilidade para orquestrar cargas de trabalho de inferência usando tempos de execução de alto desempenho como vLLM, garantindo a observabilidade e a governança do uso da ferramenta. Com esse padrão, os operadores AKS e desenvolvedores de aplicativos podem atualizar modelos ou ferramentas de forma mais integrada de forma independente e implantar recursos avançados de IA sem comprometer a confiabilidade.

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

Acesso a Ferramentas com KAITO

Para simplificar esse modelo de implantação, o complemento AI toolchain operator (KAITO) para AKS fornece uma solução gerenciada para executar serviços de inferência com suporte a chamadas de ferramentas. Ao aproveitar os espaços de trabalho de inferência KAITO, você pode criar rapidamente endpoints de modelo escaláveis e acelerados por GPU com suporte integrado para chamadas de ferramentas e APIs compatíveis com OpenAI. Isso elimina a sobrecarga operacional de configurar tempos de execução, gerenciar dependências ou dimensionar a infraestrutura manualmente.

Pré-requisitos

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

  • Monitore a implantação do espaço de trabalho com o kubectl get comando.

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

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

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

  1. Quando o espaço de trabalho estiver pronto, localize o ponto de extremidade do serviço usando o kubectl get comando.

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

    Observação

    A saída pode ser um ClusterIP ou endereço interno. Verifique em que porta(s) o serviço escuta. A API de inferência KAITO padrão está na porta 80 para HTTP. Se for apenas interno, você pode fazer a portabilidade 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 /v1/models endpoint para confirmar que o LLM está disponível usando o curl.

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

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

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

Testar a chamada de ferramenta da função nomeada

Neste exemplo, o workspace‑phi‑4‑mini-toolcall espaço de trabalho suporta a chamada de ferramenta de função nomeada por padrão, para que possamos confirmar que o LLM aceita uma especificação de "ferramenta" em solicitações no estilo OpenAI e retorna uma estrutura de "chamada de função".

O trecho 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. Presume-se que o servidor esteja a funcionar em http://localhost:8000/v1 e aceite chamadas de API no estilo OpenAI.
    • Simula a lógica de back-end de uma ferramenta chamada get_weather. (Num cenário real, isto chamaria uma API de meteorologia.)
    • Descreve a interface da ferramenta; o Phi-4-mini LLM verá essa ferramenta e decidirá se deseja usá-la 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.
    • Neste caso, a solicitação do usuário foi relevante para a get_weather ferramenta, então simulamos a execução da ferramenta, chamando a função local com os argumentos escolhidos pelo 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))

    O 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 Phi-4-mini LLM decidiu chamar a função correspondente. Agora, uma chamada de ferramenta de exemplo foi analisada e executada com êxito com base na decisão do modelo de confirmar o comportamento de chamada de ferramenta de ponta a ponta com a implantação de inferência KAITO.

Solução de problemas

A predefinição do modelo não suporta chamadas de ferramentas

Se escolher um modelo que não esteja na lista suportada, a chamada de ferramentas poderá não funcionar. Certifique-se de revisar a documentação do KAITO, que lista explicitamente quais predefinições suportam chamadas de ferramentas.

Tempo de execução desalinhado

A inferência do KAITO deve usar o tempo de execução vLLM para a chamada de ferramentas (o tempo de execução do HuggingFace Transformers geralmente não suporta chamadas de ferramentas em KAITO).

Problemas de rede/ponto final

Se estiver a reencaminhar portas, certifique-se de que as portas de serviço estão corretamente reencaminhadas. Se o servidor MCP externo estiver inacessível, ocorrerá um erro.

Interrupções

As chamadas de servidor MCP externo podem levar tempo. Verifique se o tempo de timeout do adaptador ou do cliente é suficientemente alto.

Authentication

Se o servidor MCP externo exigir autenticação (chave de API, cabeçalho, etc.), certifique-se de fornecer as credenciais corretas.

Próximos passos

  • Last updated on