Como quando você diz a seu amigo que você precisa de uma viagem para o aeroporto às 6 da manhã, e eles começam a dizer sobre seus restaurantes favoritos no aeroporto em vez disso? O que é Função Calling? A chamada de função é quando uma IA entende que precisa usar uma ferramenta ou serviço externo para completar uma tarefa.É como ter um assistente inteligente que não só entende o que você quer, mas sabe quando tirar seu telefone para verificar o tempo, procurar direções ou chamar um táxi. Em termos técnicos, a chamada de funções permite que modelos de IA identifiquem quando usar funções específicas, quais parâmetros passar e como formatar os dados corretamente - tudo a partir de instruções de linguagem natural. The Dark Ages: Antes da chamada da função Antes da chamada de função, as coisas eram... confusas.Se você queria que uma IA usasse ferramentas externas, você tinha duas opções igualmente frustrantes: 
 
 
 
 
 Train the AI to generate exact API calls (which often went wrong) 
 
 Write complex code to parse AI responses and extract parameters É como tentar ensinar alguém uma dança descrevendo os movimentos em palavras em vez de mostrá-los.Você diria algo como, "Eu preciso de dados meteorológicos para Nova York" e a IA responderia com texto sobre o tempo, não os dados reais que você precisava. Lembro-me de construir um chatbot que deveria reservar reservas de restaurante. Sem a função de chamadas, ele diria felizmente aos usuários: "Eu reservei sua mesa!" sem realmente se conectar a qualquer sistema de reservas. Por que a função chama coisas A chamada de função ponte a distância entre a linguagem humana e os sistemas de computador. 
 
 
 
 
 
 It's more reliable - the AI structures data exactly as functions need it 
 
 It's more capable - an AI can access real-time data, control devices, or run calculations 
 
 It's more natural - users can make requests in plain language Pense na chamada de função como dando a um AI acesso a uma caixa de ferramentas. Antes, ele só podia falar de martelos. Agora ele pode pegar um e realmente dirigir um prego. Uma maneira simples de pensar sobre isso Imagine que você está em uma cafeteria.Quando você diz, "Eu gostaria de um latte médio com leite de aveia", você está essencialmente "função chamando" o barista. A função pode parecer: make_coffee(size="medium", drink_type="latte", milk="oat")
 O barista sabe: 
 
 
 
 
 
 
 Identify the function needed (make a drink) 
 
 Extract the parameters (size, type, milk choice) 
 
 Execute the function (make the coffee) 
 
 Return the result (your drink) Sem a chamada de função, você obteria uma resposta como: "Um latte médio com leite de aveia soa delicioso!" mas nenhum café real. Hope you get the idea ! A mecânica do núcleo por trás da chamada de função No seu coração, a chamada de função funciona devido a várias inovações técnicas trabalhando juntas: 
 
 
 
 
 
 
 
 : When you define functions for an AI model to use, you provide a clear schema that includes the function name, description, and parameter specifications with their types and requirements. This JSON schema helps the model understand not just what the function does, but exactly what information it needs to execute properly. Structured Function Definitions 
 
 : The AI model analyzes user input to determine when a function should be called. Modern models like GPT-4 can recognize when a user's request could be satisfied by calling an external function, even when the user doesn't explicitly ask for it. Intent Recognition 
 
 : The model identifies and extracts relevant parameters from natural language, converting them into the structured format required by the function. For example, when someone asks about Microsoft stock, the model knows to extract "MSFT" as the ticker parameter. Parameter Extraction 
 
 : After a function executes, the model receives the result and incorporates it into a natural language response, creating a seamless experience for the user. Response Formatting 
 
 : The model maintains context throughout the conversation, allowing it to use previous function calls and responses to inform new function calls. Context Awareness ️ Código Scaffolding para chamada de função Aqui está um modelo que você pode usar para começar com a chamada de função usando a API OpenAI: from openai import OpenAI
import json

# Initialize the client
client = OpenAI()

# Define your functions
functions = [
    {
        "type": "function",
        "function": {
            "name": "your_function_name",
            "description": "Description of what this function does",
            "parameters": {
                "type": "object",
                "properties": {
                    "param1": {
                        "type": "string",
                        "description": "Description of parameter 1"
                    },
                    "param2": {
                        "type": "integer",
                        "description": "Description of parameter 2"
                    }
                },
                "required": ["param1"]
            }
        }
    }
]

# Your actual implementation of the function
def your_function_name(param1, param2=None):
    # Your code here
    result = f"Did something with {param1}"
    if param2:
        result += f" and {param2}"
    return result

# Process messages and handle function calls
def process_with_function_calling(messages):
    # Get response from the model
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=functions,
        tool_choice="auto"
    )
    
    response_message = response.choices[0].message
    
    # Check if the model wants to call a function
    if response_message.tool_calls:
        # Append the model's response to messages
        messages.append(response_message)
        
        # Process each function call
        for tool_call in response_message.tool_calls:
            function_name = tool_call.function.name
            function_args = json.loads(tool_call.function.arguments)
            
            # Call the function
            if function_name == "your_function_name":
                function_response = your_function_name(
                    function_args.get("param1"),
                    function_args.get("param2")
                )
                
                # Append the function response to messages
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "name": function_name,
                    "content": function_response
                })
        
        # Get a new response from the model
        second_response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages
        )
        
        return second_response.choices[0].message.content
    
    return response_message.content

# Example usage
messages = [{"role": "user", "content": "Your user query here"}]
result = process_with_function_calling(messages)
print(result)
 ☀️ Um exemplo de trabalho: meteorologista Vamos colocar isso em prática com uma simples função de verificação do tempo usando o Azure OpenAI: 

from openai import AzureOpenAI
import json
import requests


# Initialize the Azure OpenAI client
client = AzureOpenAI(
    api_key="your key",  
    api_version="2024-10-21",  # Make sure to use a version that supports function calling
    azure_endpoint="your endpoint"
)


# Define the weather function
weather_functions = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City name, e.g., 'San Francisco'"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

# Implement the weather function
def get_weather(location, unit="celsius"):
    # In a real app, you'd call a weather API here
    # This is a mock implementation
    weather_data = {
        "San Francisco": {"temp": 18, "condition": "Foggy"},
        "New York": {"temp": 22, "condition": "Partly Cloudy"},
        "London": {"temp": 15, "condition": "Rainy"},
        "Tokyo": {"temp": 24, "condition": "Sunny"}
    }
    
    # Get data for the location or return a default
    data = weather_data.get(location, {"temp": 20, "condition": "Unknown"})
    
    # Convert temperature if needed
    temp = data["temp"]
    if unit == "fahrenheit":
        temp = (temp * 9/5) + 32
    
    return f"It's currently {data['condition']} and {temp}°{'F' if unit == 'fahrenheit' else 'C'} in {location}."

# Process messages with weather function
def check_weather(user_query):
    messages = [{"role": "user", "content": user_query}]
    
    # Get response from the model
    response = client.chat.completions.create(
        model="gpt-4o-mini",  # The name you gave your deployment
        messages=[{"role": "user", "content": user_query}],
        tools=weather_functions,
        tool_choice="auto"
    )
    
    response_message = response.choices[0].message
    
    # Check if the model wants to call the weather function
    if response_message.tool_calls:
        # Append the model's response to messages
        messages.append(response_message)
        
        # Process each function call
        for tool_call in response_message.tool_calls:
            function_name = tool_call.function.name
            function_args = json.loads(tool_call.function.arguments)
            
            # Call the weather function
            if function_name == "get_weather":
                function_response = get_weather(
                    function_args.get("location"),
                    function_args.get("unit", "celsius")
                )
                
                # Append the function response to messages
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "name": function_name,
                    "content": function_response
                })
        
        # Get a new response from the model
        second_response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages
        )
        
        return second_response.choices[0].message.content
    
    return response_message.content

# Try it out
result = check_weather("What's the weather like in Tokyo right now?")
print(result)
 Quando você executa este código com a pergunta "Qual é o tempo em Tóquio agora?", a IA irá: 
 
 
 
 
 
 
 Recognize it needs weather data 
 
 Call the   function with "Tokyo" as the location get_weather 
 
 Receive the weather data 
 
 Generate a natural response with the information Em vez de adivinhar ou compilar informações meteorológicas, está fornecendo dados reais através da função. ️ A saída: função do tempo chamando a ação Quando executamos o nosso exemplo de tempo com a consulta "Como é o tempo em Tóquio agora?", a magia da função de chamada vem à vida.O modelo primeiro reconhece que esta é uma solicitação de tempo e estrutura uma chamada de função com parâmetros: Este formato JSON é enviado para o nosso função, que recupera os dados meteorológicos mock que definimos: uma temperatura de 24°C e condições "Sunny". {"location": "Tokyo", "unit": "celsius"} get_weather Quer usar OpenAI em vez do Azure OpenAI? A principal diferença entre e   A implementação está em Com o OpenAI, você usa o cliente padrão com uma chave de API direta, enquanto o Azure OpenAI requer seu cliente específico, juntamente com parâmetros adicionais como e Ao fazer chamadas de funções, a OpenAI refere os modelos pelos seus nomes padrão, enquanto o Azure OpenAI exige que você use o nome de implantação criado no seu portal do Azure. OpenAI Azure OpenAI how you initialize the client azure_endpoint api_version Aqui está a comparação de código: # Standard OpenAI implementation
from openai import OpenAI

# Initialize the client
client = OpenAI(
    api_key="your-openai-api-key"
)

# Make an API call
response = client.chat.completions.create(
    model="gpt-4o",  # Standard model name
    messages=[{"role": "user", "content": "What's the weather in Seattle?"}],
    tools=functions,
    tool_choice="auto"
)
 # Azure OpenAI implementation
from openai import AzureOpenAI

# Initialize the client - requires more parameters
client = AzureOpenAI(
    api_key="your-azure-openai-api-key",
    api_version="2023-07-01-preview",  # Azure-specific
    azure_endpoint="https://your-resource-name.openai.azure.com"  # Azure-specific
)

# Make an API call
response = client.chat.completions.create(
    model="your-deployed-model-name",  # The name you gave your deployment in Azure
    messages=[{"role": "user", "content": "What's the weather in Seattle?"}],
    tools=functions,
    tool_choice="auto"
)
 O Novo Mundo das Possibilidades A chamada de função mudou tudo. AI agora pode: 
 
 
 
 
 
 
 
 
 Book real appointments 
 
 Look up real-time data 
 
 Control smart home devices 
 
 Query databases 
 
 Process payments 
 
 And much more É a diferença entre uma IA que pode falar sobre o mundo e uma que pode realmente interagir com ele. A próxima vez que você pedir a um chatbot para as notícias de hoje ou para ligar suas luzes, lembre-se: é a função de chamar que está fazendo a magia acontecer por trás das cenas. Em resumo A chamada de função coloca uma ponte entre a linguagem humana e os sistemas de computador. Permite que a IA entenda quando chamar ferramentas e serviços externos usando dados devidamente formatados – seja que você esteja usando o OpenAI diretamente ou o Serviço OpenAI do Azure. Exploramos como ela transforma a IA de respostas passivas em agentes ativos capazes de tomar ações concretas com base em solicitações de linguagem natural. Olhando para a frente O verdadeiro poder da chamada de função não está no que pode fazer hoje, mas no que permite amanhã.À medida que mais sistemas expõem os endpoints da API e à medida que os padrões de autenticação e segurança evoluem, estamos nos aproximando de um mundo onde a linguagem natural se torna uma interface universal para sistemas digitais. O pensamento final A verdadeira revolução não é apenas que a IA pode agora agir - é que a barreira entre pensar e fazer está se dissolvendo. chamadas de função não é apenas uma característica técnica; é o momento em que a IA passou para além da página e para o mundo, transformando-se de um observador em um participante.

This story contains new, firsthand information uncovered by the writer.

Books authored by me

Cansado de chatbots quebrados? esta atualização de IA corrige tudo

About Author

COMENTARIOS

Rótulos

ESTE ARTIGO FOI APRESENTADO EM

Related Stories

Quer ganhar um concurso de redação do HackerNoon? Aqui está o que os vencedores do concurso #crypto-api recomendam

Como melhorar seu fluxo de trabalho em 10 vezes: 17 aplicativos essenciais

O guia completo para uma migração bem-sucedida para a nuvem: estratégias e práticas recomendadas

De fóruns a feeds: como os algoritmos de mídia social moldam a interação digital

Quer ganhar um concurso de redação do HackerNoon? Aqui está o que os vencedores do concurso #crypto-api recomendam

Como melhorar seu fluxo de trabalho em 10 vezes: 17 aplicativos essenciais

O guia completo para uma migração bem-sucedida para a nuvem: estratégias e práticas recomendadas

De fóruns a feeds: como os algoritmos de mídia social moldam a interação digital

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps