Llama 4 Scout na Novita AI Suporta Chamada de Funções

Destaques Principais

Novita AI apresentou o Llama 4 Scout! Além disso, esta versão suporta totalmente chamada de funções.

Se você quiser testar seu desempenho, inicie um teste gratuito diretamente no Novita AI Playground!

A chamada de funções permite que LLMs como Llama 4 Scout realizem tarefas do mundo real ao integrar APIs e ferramentas externas, transformando comandos em linguagem natural em resultados acionáveis.

O que é Chamada de Funções?

A chamada de funções representa um avanço fundamental nas capacidades dos grandes modelos de linguagem (LLMs), permitindo que interajam com ferramentas externas, APIs e fontes de dados. Ao converter prompts em linguagem natural em chamadas de função estruturadas, os LLMs podem executar ações do mundo real, recuperar informações dinâmicas e realizar computações complexas além de suas habilidades inatas de geração de texto.

Definindo Chamada de Funções

Chamada de funções é um método estruturado que permite que LLMs façam interface com sistemas externos gerando comandos executáveis com base em consultas do usuário. Diferente das saídas tradicionais de LLM, que se limitam à geração de texto, a chamada de funções permite que modelos acionem funções predefinidas com parâmetros específicos, executem essas funções por meio de código externo e integrem os resultados em respostas coerentes.

https://www.youtube.com/watch?v=i-oHvHejdsc&t=429s

Como Funciona a Chamada de Funções?

A chamada de funções envolve um processo estruturado onde um grande modelo de linguagem (LLM) interpreta prompts do usuário para determinar qual função predefinida executar e com quais parâmetros. Aqui está uma visão geral simplificada:

1. Prompt do Usuário: O usuário envia uma consulta ao sistema.
2. Interpretação do LLM: O LLM analisa o prompt para identificar a função e os parâmetros apropriados.
3. Execução da Função: O sistema executa a função com os parâmetros fornecidos.
4. Geração de Resposta: O resultado é realimentado ao LLM, que gera uma resposta final incorporando a saída.

Chamada de Funções vs. RAG

Aspecto	Chamada de Funções	Geração Aumentada por Recuperação
Definição	Chama funções externas (APIs, bancos de dados) para tarefas em tempo real.	Recupera e sintetiza informações de fontes externas para respostas.
Caso de Uso	Consultas a bancos de dados, requisições de API, ferramentas externas (ex.: pagamento).	Sistemas de perguntas e respostas que recuperam dados para gerar respostas.
Vantagens	- Tarefas em tempo real - Interage com sistemas externos - Sistemas modulares	- Acessa grande conhecimento - Eficiente para consultas complexas - Ideal para dados atualizados
Propósito	Invoca sistemas ou serviços externos.	Aprimora a geração usando conhecimento recuperado.
Implementação	Chamadas externas predefinidas (ex.: APIs).	Recupera informações durante o processo generativo.
Flexibilidade	Mais flexível para interações em tempo real.	Utiliza conhecimento externo/interno para geração.

Como Usar a Chamada de Funções do Llama 4 Scout via Novita AI

Novita AI lançou descrições de suporte de capacidade para cada LLM, que você pode visualizar diretamente no console e na documentação.

Escolha seu Modelo

1. 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 = "meta-llama/llama-4-scout-17b-16e-instruct"

• 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"})

2. Construa a Requisição de API com Ferramentas e Mensagem do Usuário

Agora, crie a requisição de API para o endpoint da Novita. Esta requisição inclui o parâmetro tools, definindo 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())

3. Output

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

4. 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 ao 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)

5. Output

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

Com Llama 4 Scout e Novita AI, a chamada de funções redefine as aplicações de LLM, oferecendo soluções dinâmicas e em tempo real para necessidades modernas.

Perguntas Frequentes

O que é chamada de funções?

Permite que LLMs acionem ferramentas externas ou APIs para realizar tarefas e recuperar dados.

Como o Llama 4 Scout funciona com chamada de funções?

O Llama 4 Scout simplifica integrações de sistemas em tempo real via Novita AI.

A chamada de funções é adequada para necessidades em tempo real?

Sim, é perfeita para tarefas como chamadas de API ou consultas de dados dinâmicos.

Novita AI é a plataforma de nuvem all-in-one que potencializa suas ambições de IA. APIs integradas, serverless, instância GPU — as ferramentas econômicas que você precisa. Elimine a infraestrutura, comece gratuitamente e torne sua visão de IA realidade.

Leitura Recomendada

• Um Guia para Acessar o DeepSeek V3: Localmente e via API
• DeepSeek V3 vs R1: Treinamento em Etapas vs Ciclos Iterativos de SFT-RL
• Executando DeepSeek V3 Localmente: Um Guia do Desenvolvedor