GPT-4.5 Funktionsaufrufe Tutorial: Aktienkurse und Nachrichten mit KI extrahieren

Große Sprachmodelle (LLMs) haben oft Schwierigkeiten, konsistent strukturierte Ausgaben wie JSON zu erzeugen, selbst wenn sie fortschrittliche Prompt-Engineering-Techniken verwenden. Eine zeitnahe Entwicklung kann die Ergebnisse zwar verbessern, ist aber nicht narrensicher - während der Prüfung können immer noch Fehler auftreten, die zu gelegentlichen Misserfolgen führen. Wie kannst du also sicherstellen, dass die strukturierten Ergebnisse jedes Mal genau und zuverlässig sind?

Der Funktionsaufruf in LLMs bezieht sich auf die Fähigkeit dieser Modelle, strukturierte Datenantworten zu erzeugen, normalerweise in Form von JSON-Objekten. Diese Funktion ermöglicht es LLMs, über die einfache Texterstellung hinauszugehen und mit externen Systemen, APIs und Tools zu interagieren. Durch den Einsatz von Funktionsaufrufen können LLMs komplexere, kontextabhängige Aufgaben durchführen und dabei die erforderliche Struktur und Genauigkeit beibehalten.

In diesem Lernprogramm lernen wir, wie man GPT-4.5, dem genauesten und sachlichsten Modell, ein funktionsaufrufendes Skript erstellt. Zunächst werden wir eine einzige Funktion implementieren, um Aktienkurse aus dem Internet zu extrahieren. Dann fügen wir eine weitere Funktion hinzu, die es dem LLM ermöglicht, zwischen mehreren Werkzeugen zu wählen und das am besten geeignete auf der Grundlage der Benutzerabfrage auszuwählen.

Am Ende dieses Tutorials wirst du lernen, wie du deine eigene intelligente Anwendung erstellst, die Aktienkurse für jedes Unternehmen liefert und auch Nachrichten-Feeds bereitstellt.

Bild vom Autor

Die Funktionsaufrufe von GPT-4.5

GPT-4.5, das neueste Modell von OpenAI, führt mehrere erweiterte Funktionen ein, darunter auch verbesserte Funktionsaufrufe. Diese Fähigkeiten sollen die Fähigkeit des Modells verbessern, mit externen Systemen zu interagieren und komplexe Aufgaben auszuführen, indem bestimmte Funktionen auf der Grundlage von Benutzereingaben aufgerufen werden.

Quelle: Modell - OpenAI API

Hier sind die wichtigsten Funktionen des Funktionsaufrufs in GPT-4.5:

1. Integration mit APIs

GPT-4.5 unterstützt Funktionsaufrufe über die Chat Completions API, Assistants API und Batch API. So können Entwickler das Modell nahtlos in ihre Anwendungen integrieren und Aufgaben wie Datenabfrage, Verarbeitung und sogar das Ausführen von Befehlen innerhalb einer Softwareumgebung übernehmen.

2. Strukturierte Ausgaben

Das Modell kann strukturierte Ausgaben wie JSON zurückgeben, was besonders für Entwickler nützlich ist, die das Modell für die Interaktion mit anderen Systemen oder Tools benötigen, die bestimmte Datenformate erfordern.

3. Vision Fähigkeiten

Der GPT-4.5 unterstützt zwar keine multimodalen Ausgaben wie Sprache oder Video, aber er unterstützt Vision-Fähigkeiten durch Bildeingaben. So kann das Modell visuelle Daten verarbeiten und analysieren, die mit Funktionsaufrufen kombiniert werden können, um Aufgaben auszuführen, die sowohl Text- als auch Bilddaten umfassen.

4. Erweiterte Funktionalitäten

Die Funktion des Funktionsaufrufs in GPT-4.5 wurde entwickelt, um komplexe Arbeitsabläufe zu vereinfachen, indem das Modell Funktionen vorschlägt oder aufruft, die du in deinem Code geschrieben hast. Das kann besonders nützlich sein, um sich wiederholende Aufgaben zu automatisieren oder KI-gesteuerte Entscheidungen in bestehende Softwaresysteme zu integrieren.

Entdecke alle Details über das neue OpenAI-Modell, indem du den Blog GPT 4.5 liest : Funktionen, Zugang, GPT-4o Vergleich & mehr.

GPT-4.5 Einzelner Funktionsaufruf

Wir werden nun ein einfaches Funktionsaufrufsystem mit dem GPT-4.5-Modell und der Yahooquery-Bibliothek erstellen. Mit der Yahooquery-Bibliothek können wir alle aktienbezogenen Daten aus Yahoo Finance extrahieren. 

Unsere Lösung ermöglicht es den Nutzern, Fragen zu Aktienkursen zu stellen, die eine bestimmte Funktion auslösen, die den Aktienkurs aus dem Internet abruft und eine Antwort erzeugt. So einfach ist das. 

Wir beginnen mit der Installation der Bibliotheken openai und yahooquery mit dem Befehl PIP.

!pip install openai yahooquery -q

Erstellen einer Aktienkursfunktion  

Erstelle eine Python-Funktion, die einen Ticker (z.B. AAPL) annimmt und den Preis dieses Tickers zurückgibt. Es verwendet yahooquery im Backend, um relevante Daten zu extrahieren.

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

Definieren der Werkzeuge mit der Funktion

Der OpenAI-Client versteht die Python-Funktion nicht, also müssen wir ein Tool erstellen, das die Liste der Wörterbücher verwendet. Wir müssen den erforderlichen Namen, die Beschreibung und den Ausgabetyp angeben. 

Wann immer diese Funktion aufgerufen wird, extrahiert sie den Tickernamen aus der Eingabeaufforderung und gibt ihn in einem strukturierten Format zurück.

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
    }
}]

Lass das Modell entscheiden, ob es die Funktion aufrufen soll

Lass uns unsere kürzlich erstellte OpenAI-Funktion testen. Gib in den Chatabschluss die Benutzernachricht, den Modellnamen und die Werkzeuge ein.

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)

Wie wir sehen können, hat GPT-4.5 die get_stock_price korrekt aufgerufen und den richtigen Ticker (META) zurückgegeben.

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

Führe die Funktion mit dem angegebenen Ticker aus

Jetzt können wir diesen Ticker an unsere get_stock_price Python-Funktion übergeben. 

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

result = get_stock_price(args["ticker"])

print(result)

Als Ergebnis erhältst du eine Antwort, die den Tickernamen und den entsprechenden Preis enthält.

META is currently trading at $640.00

Du kannst hier aufhören, aber um eine richtige Antwort in natürlicher Sprache zu geben, musst du die Ergebnisse wieder an den Chatabschluss weitergeben.

Anhängen des Funktionsaufrufs und des Toolergebnisses

Wir fügen die generierte Antwort aus der vorherigen Konversation an und fügen auch den Werkzeugaufruf mit der Werkzeug-ID und den Werkzeugergebnissen hinzu.

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

Sende die aktualisierte Konversation zurück an das Modell

Führe den Chat-Abschluss noch einmal mit der Nachricht aus, die den Inhalt der Tools enthält.

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)

Wie du sehen kannst, haben wir das richtige Ergebnis erhalten. 

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

Du denkst vielleicht, dass dies ein nutzloser Schritt ist, aber wenn du eine komplexe Ausgabe hast, hilft dir dieser Schritt, die Ergebnisse im Klartext statt im JSON-Format zu verstehen.

Wenn du über die OpenAI API verwirrt bist und mehr erfahren möchtest, solltest du den Kurs OpenAI-Grundlagen Lernpfad, um zu erfahren, wie du die OpenAI-API für die Souffleure der OpenAI-Modelle GPT und Whisper nutzen kannst.

GPT4.5 Mehrere Funktionsaufrufe

Jetzt werden wir lernen, wie wir eine weitere Funktion zu unserem KI-System hinzufügen, damit GPT-4.5 automatisch entscheiden kann, welche Funktion auf der Grundlage der Benutzerabfrage aufgerufen wird. Wir fügen eine neue Feed-Funktion hinzu, die die Top 3 Nachrichtenartikel zusammen mit den Links für den angegebenen Ticker zurückgibt. 

Installiere zunächst die Bibliothek feedparser mit dem Befehl pip. Wir werden diese Bibliothek verwenden, um die Schlagzeilen für den angegebenen Ticker zu extrahieren.

!pip install feedparser -q

Definiere die Funktion der Börsennachrichten

Erstelle die Python-Funktion get_stock_news, die den Ticker als Eingabe nimmt und die drei wichtigsten Schlagzeilen mit ihren Links zurückgibt.

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

Wir haben die drei wichtigsten Schlagzeilen über Apple mit den entsprechenden Links zusammengestellt.

'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)'

Definiere mehrere Tools für Aktienkurse und Nachrichten

Wir müssen nun eine weitere OpenAI-Funktion namens get_stock_news mit der richtigen Beschreibung und Ausgabe hinzufügen.

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
        }
    }
]

Lass das Modell entscheiden, ob es eine oder beide Funktionen aufrufen soll

Probieren wir die Funktion aus, indem wir GPT-4.5 nach Google-Aktien und den neuesten Nachrichten über Google fragen.

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

Wie wir sehen können, hat sie beide Funktionen für Aktienkurse und die neuesten Nachrichten aufgerufen.

[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')]

Speichern des Ergebnisses des Funktionsaufrufs

Das Problem ist, dass beide Funktionen den Ticker als Ergebnis zurückgeben. Wir müssen uns eine if-else-Anweisung einfallen lassen, um zu bestimmen, welche Funktion aufgerufen wird. Wir werden die Ergebnisse der Funktion im Wörterbuch speichern.

# 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"])

Anhängen des Funktionsaufrufs und der Toolergebnisse

Wir werden nun die zuvor generierten Ergebnisse und das Funktionsergebnis mit der Werkzeug-ID anhängen. 

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

Sende die aktualisierte Konversation zurück an das Modell

Wenn wir die resultierende Nachricht an den GPT-4.5 weitergeben, hat er erstaunliche Ergebnisse erzielt, die absolut vernünftig sind.

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)

Wir haben den Google-Aktienkurs und Links zu den wichtigsten Nachrichten über Google erhalten. 

Der Quellcode und die Ausgaben sind im DataLab-Arbeitsbereich. Du musst nur deinen eigenen OpenAI API-Schlüssel zur Umgebungsvariable hinzufügen und schon kannst du alles alleine ausführen.

Fazit

Wir haben große Sprachmodelle gezwungen, eine strukturierte Ausgabe zu erzeugen und sie dann an eine API oder eine andere Python-Funktion zu übergeben, um eine bestimmte Aufgabe auszuführen. Fortgeschrittene KI, wie GPT-4.5, kann mehrere Dienste oder APIs nutzen, um hoch integrierte Antworten zu generieren. 

In der Zukunft werden wir Funktionsaufrufe und Agenten nutzen, um alles um uns herum zu steuern; du musst nur einen Sprachbefehl an deine KI senden, und sie wird auf der Grundlage deines Befehls die notwendigen Werkzeuge aufrufen und Änderungen am System vornehmen.

Wir haben GPT-4.5, aber viele KI-Experten warten auf GPT-5, das näher an AGI sein soll. Alles über das kommende Modell erfährst du in unserem Blog Alles, was wir über das GPT-5 wissen .