Tutorial de chamada de função GPT-4.5: Extrair preços de ações e notícias com IA

Os modelos de linguagem de grande porte (LLMs) geralmente têm dificuldades para gerar resultados estruturados de forma consistente, como JSON, mesmo quando usam técnicas avançadas de engenharia de prompt. Embora a engenharia imediata possa melhorar os resultados, ela não é infalível - ainda podem ocorrer erros durante os testes, levando a falhas ocasionais. Então, como você pode garantir sempre resultados estruturados precisos e confiáveis?

Chamada de função em LLMs refere-se à capacidade desses modelos de produzir respostas de dados estruturados, normalmente na forma de objetos JSON. Esse recurso permite que os LLMs vão além da simples geração de texto e interajam com sistemas, APIs e ferramentas externas. Ao aproveitar a chamada de função, os LLMs podem executar tarefas mais complexas e orientadas pelo contexto, mantendo a estrutura e a precisão necessárias.

Neste tutorial, aprenderemos a usar o GPT-4.5o modelo mais preciso e factual, para criar um script de chamada de função. Primeiro, implementaremos uma única função para extrair os preços das ações da Internet. Em seguida, adicionaremos outra função, permitindo que o LLM escolha entre várias ferramentas e selecione a mais adequada com base na solicitação do usuário.

Ao final deste tutorial, você aprenderá a criar seu próprio aplicativo inteligente que pode fornecer os preços das ações de qualquer empresa e também fornecer feeds de notícias.

Imagem do autor

Recursos de chamada de função do GPT-4.5

O GPT-4.5, o modelo mais recente da OpenAI, apresenta vários recursos avançados, incluindo recursos aprimorados de chamada de função. Esses recursos são projetados para melhorar a capacidade do modelo de interagir com sistemas externos e executar tarefas complexas, invocando funções específicas com base nas entradas do usuário.

Fonte: Modelo - API OpenAI

Aqui você encontra os principais recursos do Function Calling do GPT-4.5:

1. Integração com APIs

O GPT-4.5 oferece suporte à chamada de função por meio da API de conclusões de bate-papo, da API de assistentes e da API de lote. Isso permite que os desenvolvedores integrem perfeitamente o modelo em seus aplicativos, permitindo que ele execute tarefas como recuperação de dados, processamento e até mesmo execução de comandos em um ambiente de software.

2. Saídas estruturadas

O modelo pode retornar saídas estruturadas, como JSON, o que é particularmente útil para desenvolvedores que precisam do modelo para interagir com outros sistemas ou ferramentas que exigem formatos de dados específicos.

3. Recursos de visão

Embora o GPT-4.5 não ofereça suporte a saídas multimodais, como voz ou vídeo, ele oferece suporte a recursos de visão por meio de entradas de imagem. Isso permite que o modelo processe e analise dados visuais, que podem ser combinados com chamadas de função para executar tarefas que envolvem dados de texto e de imagem.

4. Funcionalidades avançadas

O recurso de chamada de função no GPT-4.5 foi projetado para simplificar fluxos de trabalho complexos, permitindo que o modelo sugira ou invoque funções escritas em seu código. Isso pode ser particularmente útil para automatizar tarefas repetitivas ou integrar a tomada de decisões orientada por IA aos sistemas de software existentes.

Descubra todos os detalhes sobre o novo modelo OpenAI lendo o blog GPT 4.5: Recursos, acesso, comparação entre GPT-4o e mais.

GPT-4.5 Chamada de função única

Agora, criaremos um sistema simples de chamada de função usando o modelo GPT-4.5 e a biblioteca Yahooquery. A biblioteca Yahooquery nos ajudará a extrair quaisquer dados relacionados a ações do Yahoo Finance. 

Nossa solução permitirá que os usuários façam perguntas sobre os preços das ações, acionando uma função específica que recupera o preço das ações da Internet e gera uma resposta. É simples assim. 

Começaremos instalando as bibliotecas openai e yahooquery usando o comando PIP.

!pip install openai yahooquery -q

Criação de uma função de preço de ações  

Crie uma função Python que receba um ticker (por exemplo, AAPL) e retorne o preço desse ticker. Ele usa o site yahooquery no backend para extrair dados relevantes.

from openai import OpenAI
import json
from yahooquery import Ticker

def get_stock_price(ticker):
    try:
        # Create a Ticker object for the provided ticker symbol
        t = Ticker(ticker)
        # Retrieve the price data
        price_data = t.price
        # Check if we received valid data for the ticker
        if ticker in price_data and price_data[ticker].get("regularMarketPrice") is not None:
            price = price_data[ticker]["regularMarketPrice"]
        else:
            return f"Price information for {ticker} is unavailable."
    except Exception as e:
        return f"Failed to retrieve data for {ticker}: {str(e)}"
    
    return f"{ticker} is currently trading at ${price:.2f}"

Definir as ferramentas usando a função

O cliente OpenAI não entende a função Python, portanto, precisaremos criar uma ferramenta usando a lista de dicionários. Devemos fornecer o nome, a descrição e o tipo de saída necessários. 

Sempre que essa função for chamada, ela extrairá o nome do ticker do prompt e o retornará em um formato estruturado.

tools = [{
    "type": "function",
    "function": {
        "name": "get_stock_price",
        "description": "Get current stock price for a provided ticker symbol from Yahoo Finance using the yahooquery Python library.",
        "parameters": {
            "type": "object",
            "properties": {
                "ticker": {"type": "string"}
            },
            "required": ["ticker"],
            "additionalProperties": False
        },
        "strict": True
    }
}]

Deixe o modelo decidir se deve chamar a função

Vamos testar nossa função OpenAI criada recentemente. Forneça o preenchimento do bate-papo com a mensagem do usuário, o nome do modelo e as ferramentas.

client = OpenAI()

messages = [{"role": "user", "content": "What's the current price of Meta stock?"}]

completion = client.chat.completions.create(
    model="gpt-4.5-preview",
    messages=messages,
    tools=tools,
)

print(completion.choices[0].message.tool_calls)

Como podemos ver, o GPT-4.5 invocou com precisão o site get_stock_price e retornou o ticker correto (META).

[ChatCompletionMessageToolCall(id='call_uVGbahRiMnn4AkOJYbv8gfIV', function=Function(arguments='{"ticker":"META"}', name='get_stock_price'), type='function')]

Execute a função com o ticker fornecido

Agora você pode fornecer esse ticker à nossa função Python get_stock_price. 

tool_call = completion.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)

result = get_stock_price(args["ticker"])

print(result)

Como resultado, você recebe uma resposta que inclui o nome do ticker e seu preço correspondente.

META is currently trading at $640.00

Você pode parar por aqui, mas para fornecer uma resposta adequada em linguagem natural, é necessário passar os resultados para a conclusão do chat novamente.

Anexar a chamada de função e o resultado da ferramenta

Anexaremos a resposta gerada da conversa anterior e também incluiremos a chamada da ferramenta com a ID da ferramenta e os resultados da ferramenta.

messages.append(completion.choices[0].message)  # Model's function call message
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": str(result)
})

Envie a conversa atualizada de volta para o modelo

Execute a conclusão do chat novamente com a mensagem que inclui o conteúdo da chamada de ferramentas.

completion_2 = client.chat.completions.create(
    model="gpt-4.5-preview",
    messages=messages,
    tools=tools,
)

# The final model response incorporating the stock price information
print(completion_2.choices[0].message.content)

Como você pode ver, obtivemos o resultado correto. 

The current price of Meta stock (META) is $640.00.

Você pode pensar que essa é uma etapa inútil, mas quando você tem uma saída complexa, essa etapa o ajudará a entender os resultados em inglês simples, em vez dos resultados no formato JSON.

Se você estiver confuso sobre a API da OpenAI e quiser saber mais, considere fazer o curso Fundamentos da OpenAI para que você saiba como usar a API do OpenAI para solicitar os modelos GPT e Whisper do OpenAI.

GPT4.5 Chamada de várias funções

Agora, aprenderemos como adicionar outra função ao nosso sistema de IA para que o GPT-4.5 possa decidir automaticamente qual função invocar com base no prompt do usuário. Estamos adicionando uma nova função de feed que retornará os três principais artigos de notícias juntamente com os links para o ticker especificado. 

Comece instalando a biblioteca feedparser usando o comando pip. Usaremos essa biblioteca para extrair as manchetes do ticker especificado.

!pip install feedparser -q

Defina a função de notícias sobre ações

Crie a função Python get_stock_news que receberá o ticker como entrada e retornará as três principais manchetes de notícias com seus links.

import feedparser


def get_stock_news(ticker):
    # Construct the RSS feed URL for the given ticker.
    rss_url = f"https://feeds.finance.yahoo.com/rss/2.0/headline?s={ticker}&region=US&lang=en-US"
    try:
        feed = feedparser.parse(rss_url)
        if not feed.entries:
            return f"No news found for {ticker}."
        # Extract the top 3 news items (title and link)
        news_items = []
        for entry in feed.entries[:3]:
            title = entry.get("title", "No Title")
            link = entry.get("link", "No Link")
            news_items.append(f"{title} ({link})")
        news_str = "\n".join(news_items)
    except Exception as e:
        return f"Failed to retrieve news for {ticker}: {str(e)}"
    
    return f"Latest news for {ticker}:\n{news_str}"

get_stock_news("AAPL")

Reunimos as três principais manchetes sobre a Apple com os links apropriados.

'Latest news for AAPL:\nNvidia AI Server Maker Hon Hai Posts 25% Jump in Two-Month Sales 
(https://finance.yahoo.com/news/nvidia-ai-server-maker-hon-075011863.html?.tsrc=rss)\nFoxconn says February revenue rose 56.43% y/y
(https://finance.yahoo.com/news/foxconn-says-february-revenue-rose-074433615.html?.tsrc=rss)\nApple Inc. (AAPL): Among the Best Stocks To Invest In According to Billionaires 
(https://finance.yahoo.com/news/apple-inc-aapl-among-best-051548210.html?.tsrc=rss)'

Definir várias ferramentas para preços de ações e notícias

Agora precisamos adicionar outra função OpenAI chamada get_stock_news com a descrição e a saída adequadas.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_stock_price",
            "description": "Get current stock price for a provided ticker symbol using yahooquery.",
            "parameters": {
                "type": "object",
                "properties": {
                    "ticker": {"type": "string"}
                },
                "required": ["ticker"],
                "additionalProperties": False
            },
            "strict": True
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_stock_news",
            "description": "Get the latest news for a provided ticker symbol by parsing the Yahoo Finance RSS feed using feedparser.",
            "parameters": {
                "type": "object",
                "properties": {
                    "ticker": {"type": "string"}
                },
                "required": ["ticker"],
                "additionalProperties": False
            },
            "strict": True
        }
    }
]

Deixe o modelo decidir se deve chamar uma ou ambas as funções

Vamos tentar testar a função perguntando ao GPT-4.5 sobre as ações do Google e as últimas notícias sobre o Google.

messages = [{
    "role": "user",
    "content": "What's the current price of Google stock and can you show me the latest news about it?"
}]


completion = client.chat.completions.create(
    model="gpt-4.5-preview",
    messages=messages,
    tools=tools,
)

completion.choices[0].message.tool_calls

Como podemos ver, ele invocou as duas funções para os preços das ações e as últimas notícias.

[ChatCompletionMessageToolCall(id='call_zfcRJ4EcIUUqHCcN8SErjeoi', function=Function(arguments='{"ticker": "GOOGL"}', name='get_stock_price'), type='function'),
 ChatCompletionMessageToolCall(id='call_jBv8TlSPOyFKcRWHwByxLMb4', function=Function(arguments='{"ticker": "GOOGL"}', name='get_stock_news'), type='function')]

Salvando o resultado da chamada de função

O problema é que ambas as funções retornam o ticker como resultado. Temos que criar uma instrução if-else para determinar qual função será chamada. Armazenaremos os resultados da função no dicionário.

# The model returns function call requests.
tool_calls = completion.choices[0].message.tool_calls

# Execute each function call based on the tool the model requested
tool_results = {}
for tool_call in tool_calls:
    func_name = tool_call.function.name
    args = json.loads(tool_call.function.arguments)
    if func_name == "get_stock_price":
        tool_results["price"] = get_stock_price(args["ticker"])
    elif func_name == "get_stock_news":
        tool_results["news"] = get_stock_news(args["ticker"])

Anexar a chamada de função e os resultados da ferramenta

Agora, vamos anexar os resultados gerados anteriormente e o resultado da função com a ID da ferramenta. 

messages.append(completion.choices[0].message)  # Append the model's function call message

for tool_call in tool_calls:
    func_name = tool_call.function.name
    result_content = tool_results.get("price") if func_name == "get_stock_price" else tool_results.get("news")
    messages.append({
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": result_content
    })

Envie a conversa atualizada de volta para o modelo

Quando passamos a mensagem resultante para o GPT-4.5, ele gerou resultados surpreendentes que são perfeitamente razoáveis.

from IPython.display import display, Markdown

completion_2 = client.chat.completions.create(
    model="gpt-4.5-preview",
    messages=messages,
    tools=tools,
)

# The final model response incorporates both stock price and news.
Markdown(completion_2.choices[0].message.content)

Obtivemos o preço das ações do Google e links para as principais notícias sobre o Google. 

O código-fonte e os resultados estão disponíveis no Espaço de trabalho do DataLab. Tudo o que você precisa fazer é adicionar sua própriachave de API OpenAI à variável de ambiente, e você poderá executar tudo sozinho.

Conclusão

Forçamos grandes modelos de linguagem a gerar saída estruturada e, em seguida, passá-la para uma API ou outra função Python para executar uma tarefa específica. A IA avançada, como o GPT-4.5, pode usar vários serviços ou APIs para gerar respostas altamente integradas. 

No futuro, usaremos chamadas de função e agentes para controlar tudo ao nosso redor; basta enviar um comando de voz para a sua IA, e ela invocará as ferramentas necessárias com base no seu comando e fará alterações no sistema.

Temos o GPT-4.5, mas muitos especialistas em IA estão aguardando o GPT-5, que deverá estar mais próximo do AGI. Você pode saber tudo sobre o próximo modelo lendo o blog Tudo o que sabemos sobre o GPT-5 .