Seu Manual de Chamada de Funções do GLM 4.5: Da Integração à Resolução de Problemas

O GLM 4.5, como um modelo de linguagem grande (LLM) avançado com capacidades de agente, eleva a automação e a tomada de decisões inteligentes ao próximo nível por meio da chamada de funções. Ao aproveitar a chamada de funções, o GLM 4.5 pode interagir com ferramentas e APIs externas, executar ações, recuperar dados e automatizar fluxos de trabalho complexos — tornando-se muito mais do que apenas um modelo conversacional.

No entanto, integrar e solucionar problemas de chamada de funções pode ser desafiador. Este artigo fornece orientações práticas e soluções para problemas comuns que você pode encontrar ao usar a chamada de funções com o GLM 4.5, como erros de parser, formatos de saída incorretos ou armadilhas no design de esquemas. Por meio de exemplos claros, dicas de solução de problemas e melhores práticas, este artigo ajuda você a identificar e resolver problemas rapidamente — permitindo que você libere todo o potencial agente do GLM 4.5 em suas aplicações do mundo real.

Que Resultados Melhores a Chamada de Funções Pode Ajudar o GLM 4.5 a Alcançar?

A chamada de funções é um recurso poderoso introduzido em modelos de linguagem grandes como o GLM 4.5. Ela permite que o modelo interaja com ferramentas externas, APIs ou código estruturado de forma controlada e confiável. Veja a seguir os principais benefícios e resultados aprimorados que a chamada de funções traz para o GLM 4.5:

https://www.youtube.com/watch?v=KUEmEb71vzQ

1. Saídas Mais Precisas e Confiáveis

• Maior Fidelidade aos Fatos: Ao delegar tarefas como cálculos, buscas de dados ou consultas a bancos de dados para funções externas, o GLM 4.5 pode evitar erros comuns em respostas puramente baseadas em texto.
• Menos Alucinações: O modelo se baseia em resultados verificados de APIs ou funções, reduzindo a chance de gerar informações incorretas ou inventadas.

2. Automação de Tarefas Complexas

• Encadeamento de Tarefas: O GLM 4.5 pode dividir uma solicitação do usuário em várias etapas, chamando as funções apropriadas para cada etapa e combinando os resultados.
• Automação de Fluxos de Trabalho: Ele pode automatizar processos de negócios de várias etapas, processamento de dados ou geração de relatórios, orquestrando sequências de chamadas de funções.

3. Integração Aprimorada com Sistemas do Mundo Real

• Acesso a Dados em Tempo Real: Com a chamada de funções, o modelo pode buscar informações em tempo real de bancos de dados, serviços web ou dispositivos IoT, tornando suas respostas mais atualizadas e conscientes do contexto.
• Ações Personalizadas: As empresas podem definir funções personalizadas (por exemplo, enviar e-mails, fazer pedidos), permitindo que o modelo execute ações específicas do domínio de forma segura.

4. Experiência do Usuário Aprimorada

• Aplicativos Interativos: Os usuários podem interagir com o modelo como se estivessem usando um aplicativo, com o modelo acionando funções de backend de forma transparente.
• Personalização: As funções podem buscar dados ou configurações específicas do usuário, permitindo respostas personalizadas.

5. Melhor Tratamento de Erros e Explicabilidade

• Raciocínio Transparente: A chamada de funções ajuda a rastrear quais recursos ou ferramentas externas foram usados, tornando o processo de raciocínio do modelo mais auditável.
• Execução Controlada: Os desenvolvedores podem monitorar e limitar quais funções o modelo pode chamar, melhorando a segurança e a previsibilidade.

Quais são as limitações da chamada de funções no GLM-4.5?

1. Chamadas Excessivas
O GLM-4.5 às vezes pode fazer chamadas excessivas ou desnecessárias para ferramentas ou APIs externas. Isso aumenta o uso de tokens e os custos operacionais, pois mais recursos computacionais são consumidos sem sempre beneficiar o resultado final.

2. Casos Extremos de Streaming
No modo de streaming, se dados JSON parciais forem enviados antes que a resposta completa esteja pronta, os aplicativos downstream podem receber informações incompletas. Sem um buffer adequado, isso pode levar a erros ou falhas no processamento da saída.

3. Pegada de Recursos
Para a chamada de funções, isso significa que recursos de hardware limitados podem impactar a capacidade do modelo de lidar eficientemente com um grande número de solicitações, processar dados complexos ou executar cadeias intrincadas de chamadas de ferramentas. Em ambientes com recursos restritos, o desempenho e a precisão da chamada de funções podem ser reduzidos de forma perceptível.

Benefícios do Uso de Chamada de Funções com o GLM-4.5

Uma avaliação independente das capacidades de codificação agente do GLM-4.5 foi realizada usando o Claude Code, abrangendo 52 tarefas de codificação diversas, como desenvolvimento frontend, criação de ferramentas, análise de dados, testes e implementação de algoritmos. O GLM-4.5 atingiu uma taxa de sucesso de chamada de ferramentas de 90,6%, superando o Claude-4-Sonnet (89,5%), o Kimi K2 (86,2%) e o Qwen3-Coder (77,1%).

Tutorial: Usando a Chamada de Funções no GLM-4.5 para Iniciantes

Este guia demonstra como usar a Chamada de Funções para recuperar informações meteorológicas atuais para a localização especificada por um usuário. Vamos percorrer um exemplo completo de código Python.

Para o formato de API específico da Chamada de Funções, consulte a Documentação!

Experimente o GLM 4.5 Agora!

• Inicialize o Cliente

Primeiro, você precisa inicializar o cliente com sua chave de API Novita.

from openai import OpenAI
import json

client = OpenAI(
    base_url="https://api.novita.ai/v3/openai",
    # Get the Novita AI API Key from: https://novita.ai/settings/key-management.
    api_key="<YOUR Novita AI API Key>",
)

model = "zai-org/glm-4.5"

• Defina a Função a Ser Chamada

Em seguida, defina a função Python que o modelo pode chamar. Neste exemplo, é uma função para obter informações meteorológicas.

# Example function to simulate fetching weather data.
def get_weather(location):
    """Retrieves the current weather for a given location."""
    print("Calling get_weather function with location: ", location)
    # In a real application, you would call an external weather API here.
    # This is a simplified example returning hardcoded data.
    return json.dumps({"location": location, "temperature": "60 degrees Fahrenheit"})

• Construa a Solicitação de API com Ferramentas e Mensagem do Usuário

Agora, crie a solicitação de API para o endpoint Novita. Esta solicitação inclui o parâmetro tools, que define as funções que o modelo pode usar, e a mensagem do usuário.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather of an location, the user shoud supply a location first",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    }
                },
                "required": ["location"]
            },
        }
    },
]

messages = [
    {
        "role": "user",
        "content": "What is the weather in San Francisco?"
    }
]

# Let's send the request and print the response.
response = client.chat.completions.create(
    model=model,
    messages=messages,
    tools=tools,
)

# Please check if the response contains tool calls if in production.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())

• Saída

{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}

• Responda com o Resultado da Chamada de Função e Obtenha a Resposta Final

O próximo passo é processar a chamada de função, executar a função get_weather e enviar o resultado de volta para o modelo para gerar a resposta final ao usuário.

# Ensure tool_call is defined from the previous step
if tool_call:
    # Extend conversation history with the assistant's tool call message
    messages.append(response.choices[0].message)

    function_name = tool_call.function.name
    if function_name == "get_weather":
        function_args = json.loads(tool_call.function.arguments)
        # Execute the function and get the response
        function_response = get_weather(
            location=function_args.get("location"))
        # Append the function response to the messages
        messages.append(
            {
                "tool_call_id": tool_call.id,
                "role": "tool",
                "content": function_response,
            }
        )

    # Get the final response from the model, now with the function result
    answer_response = client.chat.completions.create(
        model=model,
        messages=messages,
        # Note: Do not include tools parameter here.
    )
    print(answer_response.choices[0].message)

• Saída

{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}

Novita AI Agora Oferece Compatibilidade com o SDK Anthropic

A combinação do GLM-4.5 e do Claude Code ganhou atenção rapidamente na comunidade de IA, entregando capacidades agente avançadas para aplicações do mundo real. Para agilizar ainda mais essa integração, a Novita AI agora oferece compatibilidade com o SDK Anthropic, permitindo que você aproveite facilmente o poder do GLM-4.5 por meio da interface familiar do Claude Code.

Você pode consultar esta documentação para obter mais detalhes!

1. Instale o SDK Anthropic

pip install anthropic

2. Inicialize o Cliente

Os SDKs Anthropic são projetados para obter a chave de API e a URL base das variáveis de ambiente: ANTHROPIC_API_KEY e ANTHROPIC_BASE_URL. Além disso, você pode fornecer os parâmetros para o cliente Anthropic ao inicializá-lo.

Você pode visualizar e gerenciar suas chaves de API na página de configurações.

• Usando Variáveis de Ambiente

export ANTHROPIC_BASE_URL="https://api.novita.ai/anthropic"
export ANTHROPIC_API_KEY="<YOUR_NOVITA_API_KEY>"

• Defina os parâmetros ao inicializar o cliente Anthropic

import anthropic

client = anthropic.Anthropic(
    base_url="https://api.novita.ai/anthropic",
    api_key="<YOUR_NOVITA_API_KEY>"
)

3. Chame a API

import anthropic

# Initialize the client, if you already set `ANTHROPIC_BASE_URL` and `ANTHROPIC_API_KEY` 
# in the environment variables, you can omit the `api_key` and `base_url` parameters.
client = anthropic.Anthropic(
    base_url="https://api.novita.ai/anthropic",
    api_key="<YOUR_NOVITA_API_KEY>"
)

message = client.messages.create(
    model="zai-org/glm-4.5",
    max_tokens=1000,
    temperature=1,
    system="You are a world-class poet. Respond only with short poems.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Why is the ocean salty?"
                }
            ]
        }
    ]
)

print(message.content)

Como Melhorar a Precisão da Chamada de Funções do GLM-4.5

1. Clareza de Esquema

• O que significa: Use nomes de parâmetros curtos e exclusivos e evite anyOf aninhado até que o parser seja mais robusto.
• O que resolve:
  • Evita confusão de parâmetros e conflitos de nomenclatura, facilitando para o modelo preencher os argumentos corretamente.
  • Reduz erros de parsing e chamadas de função com falha causadas por esquemas excessivamente complexos.

2. Prompt do Sistema

• O que significa: Instrua o modelo a “primeiro decidir se uma ferramenta é necessária; caso contrário, responda diretamente”.
• O que resolve:
  • Reduz chamadas desnecessárias ou excessivas de ferramentas/funções (chamadas excessivas).
  • Ajuda a economizar recursos computacionais e custos operacionais.

3. Temperatura ≤ 0.2

• O que significa: Defina o parâmetro de temperatura para 0.2 ou inferior.
• O que resolve:
  • Reduz a aleatoriedade da saída, garantindo um comportamento mais previsível e consistente.
  • Evita desvio de esquema, para que o modelo mantenha a estrutura de parâmetros pretendida e reduza erros.

4. Use tool_choice="required"

• O que significa: Defina essa opção quando o usuário solicitar explicitamente uma chamada de função.
• O que resolve:
  • Garante que o modelo sempre faça a chamada de função necessária, melhorando a confiabilidade e a satisfação do usuário.

5. Use Chamadas Paralelas com Moderação

• O que significa: Paralelize apenas funções verdadeiramente independentes; caso contrário, gere chamadas sequencialmente.
• O que resolve:
  • Evita mistura de argumentos ou inconsistência lógica entre chamadas.
  • Garante que cada chamada receba o contexto e as entradas corretos, levando a resultados mais precisos.

Solução de Problemas de Erros de Chamada de Funções do GLM-4.5

Sintoma	Causa Provável	Correção / Solução
IndexError: list index out of range no parser	Usando o parser padrão; o formato de ID do GLM é diferente.	Inicie o servidor com --tool-call-parser glm4_moe.
Texto aleatório misturado com JSON	Temperatura muito alta ou tool_choice ausente.	Diminua a temperatura; defina tool_choice como "auto" ou "required".
Recursão infinita de ferramentas	O modelo está alucinando chamadas repetidas.	Rastreie as chamadas executadas e aborte duplicatas na lógica do host.
OOM / Falta de Recursos	A compilação FP8 ainda excede a memória compartilhada nos kernels Triton.	Reduza num_stages ou mude para a quantização Int4-Int8-Mix.
Nenhuma chamada emitida	O esquema da ferramenta é muito vago.	Adicione uma lista required estrita e valores de enum explícitos.

A chamada de funções transforma o GLM 4.5 de um modelo conversacional em um agente inteligente que pode executar tarefas e automatizar processos em tempo real. Ao entender problemas típicos e suas soluções — como erros de parser, formatação JSON ou design de esquemas — você pode garantir uma integração tranquila e liberar todo o potencial das habilidades agente do GLM 4.5. Esperamos que este artigo tenha esclarecido dúvidas comuns e capacitado você a implantar a chamada de funções do GLM 4.5 com confiança.

Perguntas Frequentes

Por que a chamada de funções é importante para o GLM 4.5 como um LLM agente? A chamada de funções permite que o GLM 4.5 interaja programaticamente com serviços externos, bancos de dados e ferramentas. Isso possibilita automação, raciocínio de várias etapas, recuperação de informações e ações do mundo real além da geração de texto.

Como evito recursão infinita ou chamadas de ferramentas repetidas? Implemente lógica no lado do host para rastrear e abortar chamadas de função duplicadas, evitando loops infinitos.

Quais são as melhores práticas para design de esquemas para garantir que as chamadas de função sejam emitidas? Use nomes de parâmetros concisos e exclusivos, forneça enums explícitos e defina parâmetros obrigatórios para tornar o esquema claro para o modelo.

Novita AI é a plataforma de nuvem tudo-em-um que capacita suas ambições de IA. APIs integradas, serverless, Instâncias de GPU — as ferramentas econômicas que você precisa. Elimine a infraestrutura, comece gratuitamente e torne sua visão de IA uma realidade.

Leitura Recomendada

• Guia para Acessar o DeepSeek V3: Localmente e via API
• DeepSeek V3 vs R1: Treinamento em Estágios vs Ciclos Iterativos de SFT-RL
• GLM 4.1V 9B Thinking VRAM: Uma A100 é Suficiente?