Os modelos de IA modernos estão evoluindo além da simples geração de texto. Com recursos como Function Calling e Structured Outputs, os desenvolvedores agora podem criar aplicações mais inteligentes e confiáveis. Na Novita AI, você pode verificar rapidamente se um modelo suporta essas capacidades diretamente no Console — tornando a integração mais rápida e eficiente.
O que é Function Calling?
Function calling é uma capacidade em IA, especialmente com modelos de linguagem de grande porte (LLMs), que permite ao modelo interagir com funções externas, ferramentas ou APIs para executar tarefas específicas além de gerar respostas em texto. Em vez de apenas produzir texto, o modelo identifica quando uma determinada função deve ser chamada com base no prompt do usuário, determina a função correta a invocar e especifica os parâmetros necessários para essa função. A execução real da função é tratada por um sistema ou aplicação externa, não pelo próprio modelo.
https://www.youtube.com/watch?v=aqdWSYWC\_LI
Como o Function Calling Funciona?
O Function Calling permite que modelos de IA interajam com ferramentas externas, APIs ou funções internas durante uma conversa. Em vez de simplesmente gerar texto, o modelo pode reconhecer quando uma função é necessária, gerar a chamada de função correta com argumentos estruturados e executá-la para obter resultados. Isso preenche a lacuna entre a compreensão da linguagem natural e a ação no mundo real, permitindo que os modelos realizem tarefas como buscar dados em tempo real, gerenciar fluxos de trabalho ou acionar ações do sistema automaticamente.
Quais São os Benefícios do Function Calling?
- Interação com o Mundo Real: Os modelos podem acionar ações, não apenas fornecer informações.
- Automação: Simplifique processos como recuperação de dados, reservas, envio de formulários e muito mais.
- Compreensão Estruturada: Em vez de depender apenas da geração de texto, o modelo organiza a saída em formatos predefinidos, reduzindo erros.
- Casos de Uso Aprimorados: Crie aplicações dinâmicas, assistentes e sistemas mais confiáveis e eficientes.
- Eficiência do Desenvolvedor: Ao saber que um modelo suporta Function Calling antecipadamente, você pode planejar integrações mais rapidamente, sem modificações pesadas.
O que são Structured Outputs?
Structured outputs referem-se à capacidade dos modelos de linguagem de grande porte (LLMs) de gerar respostas que obedecem a um formato predefinido e específico, em vez de produzir texto livre. Essas saídas geralmente estão em formatos legíveis por máquina, como JSON, XML, modelos preenchidos ou dados tabulares, o que torna mais fácil analisá-las, validá-las e integrá-las em sistemas de software ou fluxos de trabalho.
Como os Structured Outputs São Gerados
- Técnicas de Prompting: O modelo é guiado por prompts cuidadosamente elaborados para produzir a saída no formato desejado.
- APIs de Function Calling: De forma mais robusta, structured outputs podem ser gerados usando interfaces de function calling, onde o modelo retorna argumentos que obedecem estritamente ao esquema de uma função, muitas vezes aplicado pela definição de parâmetros como
strict: true. - Orientação por Máquina de Estados Finitos (FSM): Internamente, a geração pode ser restringida para que cada token produzido respeite as regras do formato de saída, reduzindo erros de estrutura.
Casos de Uso e Benefícios
- Extração de dados estruturados a partir de texto não estruturado, como detalhes de eventos, informações de usuários ou parâmetros de consulta.
- Acionamento de APIs ou funções externas com parâmetros precisos gerados pelo modelo.
- Construção de fluxos de trabalho complexos de várias etapas que dependem de troca de dados consistente e validada.
- Melhoria da confiabilidade em aplicações como chatbots, extração de dados e sistemas de automação, reduzindo a ambiguidade nas saídas do modelo.
Function Calling vs Structured Outputs
| Aspecto | 🛠️ Function Calling | 🗂️ Structured Outputs |
|---|---|---|
| Propósito | Acionar uma função externa | Retornar informações estruturadas |
| Orientação | Orientado à ação | Orientado à informação |
| Saída | Nome da função + argumentos | Dados estruturados predefinidos (ex.: JSON) |
| Exemplo | Chamar uma API meteorológica para obter a previsão | Retornar um relatório meteorológico em formato JSON |
| Cenário de Uso | Quando você precisa que o modelo realize uma ação | Quando você precisa de dados limpos e analisáveis sem ação |
Como Verificar Function Calling e Structured Outputs na Novita AI?
1: Faça login na Novita AI
Ao acessar a página inicial da Novita AI, clique no botão “Log In” ou “Get Started” no canto superior direito. Você pode fazer login facilmente com Google, GitHub, Hugging Face ou apenas com seu E-mail — à sua escolha!
Experimente a Novita AI Agora!
Clique em “Model API” no Console!
Após fazer login, você será direcionado ao painel do Console da Novita. No topo, clique em “Model API”. Esta seção fornece acesso a uma lista completa de modelos disponíveis, juntamente com informações detalhadas sobre suas capacidades — incluindo se suportam Function Calling e Structured Outputs.
Escolha seu Modelo e Verifique!
Basta encontrar o modelo de seu interesse, clicar nele e um painel aparecerá à direita. Em “Supported Capabilities”, você verá instantaneamente se Function Calling e Structured Outputs são suportados.
Como Usar Function Calling na Novita AI?
1. Inicialize o Cliente
Primeiro, você precisa inicializar o cliente com sua chave de API da Novita.
from openai import OpenAI
import json
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
# Obtenha a chave da API Novita AI em: https://novita.ai/settings/key-management.
api_key="<YOUR Novita AI API Key>",
)
model = "meta-llama/llama-4-maverick-17b-128e-instruct-fp8"
- 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.
# Exemplo de função para simular a obtenção de dados meteorológicos.
def get_weather(location):
"""Recupera o clima atual para um determinado local."""
print("Chamando a função get_weather com local: ", location)
# Em uma aplicação real, você chamaria uma API meteorológica externa aqui.
# Este é um exemplo simplificado que retorna dados fixos.
return json.dumps({"location": location, "temperature": "60 degrees Fahrenheit"})
2. Construa a Solicitação de API com Tools e Mensagem do Usuário
Agora, crie a solicitação de API para o endpoint da Novita. Esta solicitaçã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": "Obter o clima de um local, o usuário deve fornecer um local primeiro",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "A cidade e estado, ex: São Francisco, CA"
}
},
"required": ["location"]
},
}
},
]
messages = [
{
"role": "user",
"content": "Qual é o clima em São Francisco?"
}
]
# Vamos enviar a solicitação e imprimir a resposta.
response = client.chat.completions.create(
model=model,
messages=messages,
tools=tools,
)
# Verifique se a resposta contém tool calls se estiver em produção.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())
3. Saída
{'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.
# Certifique-se de que tool_call foi definido na etapa anterior
if tool_call:
# Estenda o histórico da conversa com a mensagem de chamada de ferramenta do assistente
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 a função e obtenha a resposta
function_response = get_weather(
location=function_args.get("location"))
# Anexe a resposta da função às mensagens
messages.append(
{
"tool_call_id": tool_call.id,
"role": "tool",
"content": function_response,
}
)
# Obtenha a resposta final do modelo, agora com o resultado da função
answer_response = client.chat.completions.create(
model=model,
messages=messages,
# Nota: Não inclua o parâmetro tools aqui.
)
print(answer_response.choices[0].message)
5. Saída
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
Como Usar Structured Outputs na Novita AI?
1. Inicialize o Cliente
Primeiro, você precisa inicializar o cliente com sua chave de API da Novita.
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
# Obtenha a chave da API Novita AI em: https://novita.ai/settings/key-management.
api_key="<YOUR Novita AI API Key>",
)
# Acesse a página [Models](https://novita.ai/models) para ver os modelos que suportam `Structured Outputs`.
model = "mistralai/mistral-7b-instruct"
2. Defina o Esquema JSON
Este exemplo cria um esquema para extrair informações de despesas da entrada do usuário.
# Defina o prompt do sistema para rastreamento de despesas.
system_prompt = """Você é um assistente de rastreamento de despesas.
Extraia informações de despesas da entrada do usuário e formate-as de acordo com o esquema fornecido."""
# Defina o esquema JSON para resposta estruturada.
response_format = {
"type": "json_schema",
"json_schema": {
"name": "expense_tracking_schema",
"schema": {
"type": "object",
"properties": {
"expenses": {
"type": "array",
"items": {
"type": "object",
"properties": {
"description": {
"type": "string",
"description": "Descrição da despesa"
},
"amount": {
"type": "number",
"description": "Valor gasto em dólares"
},
"date": {
"type": "string",
"description": "Quando a despesa ocorreu"
},
"category": {
"type": "string",
"description": "Categoria da despesa (ex.: alimentação, escritório, viagem)"
}
},
"required": [
"description",
"amount"
]
}
},
"total": {
"type": "number",
"description": "Valor total de todas as despesas"
}
},
"required": [
"expenses",
"total"
],
},
},
}
3. Solicite a API de chat completion
Agora, faça a solicitação de chat completion para o endpoint da Novita.
Esta solicitação inclui o parâmetro response_format, definindo o esquema JSON que definimos na etapa anterior.
chat_completion = client.chat.completions.create(
model=model,
messages=[
{
"role": "system",
"content": system_prompt,
},
{
"role": "user",
"content": """Gastei $120 em um jantar em um restaurante italiano na sexta-feira passada com meus colegas.
Também comprei materiais de escritório por $45 na segunda-feira.""",
},
],
max_tokens=1024,
temperature=0.8,
stream=False,
response_format=response_format,
)
response_content = chat_completion.choices[0].message.content
# Analise e prettifique o JSON
try:
json_response = json.loads(response_content)
prettified_json = json.dumps(json_response, indent=2)
print(prettified_json)
except json.JSONDecodeError:
print("Não foi possível analisar a resposta como JSON. Resposta bruta:")
print(response_content)
4. Saída:
{
"expenses": [
{
"date": "2023-03-17",
"description": "Jantar em restaurante italiano",
"amount": 120,
"category": "Alimentação"
},
{
"date": "2023-03-13",
"description": "Materiais de escritório",
"amount": 45,
"category": "Suprimentos de escritório"
}
],
"total": 165
}
Function Calling e Structured Outputs expandem significativamente o que os modelos de IA podem fazer. Seja para automatizar fluxos de trabalho, buscar dados em tempo real ou extrair informações estruturadas, a Novita AI facilita encontrar modelos que atendam às suas necessidades. Comece a criar aplicações mais inteligentes hoje mesmo explorando os modelos no Console Novita!
Perguntas Frequentes
O que é Function Calling em modelos de IA?
Permite que os modelos acionem ferramentas ou APIs externas gerando chamadas de função estruturadas com base em prompts do usuário.
O que são Structured Outputs?
Structured Outputs referem-se a respostas do modelo em formatos estritos e legíveis por máquina, como JSON, ideais para integração fácil.
Como Function Calling e Structured Outputs são diferentes?
Function Calling é orientado a ações (por exemplo, buscar clima), enquanto Structured Outputs focam em retornar dados limpos e formatados.
Novita AI é a plataforma all-in-one na nuvem que impulsiona suas ambições de IA. APIs integradas, serverless, GPU Instance — as ferramentas econômicas que você precisa. Elimine infraestrutura, comece gratuitamente e torne sua visão de IA realidade.
