In meinem Letzter Beitragwie man mithilfe des JSON-Modus, Funktionsaufrufen und strukturierten Ausgaben strukturierte, maschinenlesbare Ausgaben als Antwort von einem LLM erhält. In diesem Beitrag haben wir die Idee des Funktionsaufrufs kurz angesprochen und ihn als Methode zum Erhalten strukturierter Antworten betrachtet. Dennoch geht der Funktionsaufruf weit über das bloße Zurückholen strukturierter Daten aus einem Modell hinaus, da er im Wesentlichen das Rückgrat von darstellt Agentische KI-Workflows. Deshalb werden wir uns im heutigen Beitrag genau mit diesem Thema beschäftigen.

In allen Beispielen, die wir bisher behandelt haben, wird der LLM nur als passiver Responder verwendet, das heißt, er empfängt eine Frage und generiert dann eine Antwort, und das conflict’s. Was aber, wenn wir wollen, dass das LLM nicht nur mit etwas antwortet, sondern mit etwas? etwas tun? Oder genauer gesagt: Was wäre, wenn wir möchten, dass eine Aktion basierend auf der Reaktion des Modells ausgelöst wird? Diese Aktion kann alles sein: Reside-Daten nachschlagen, eine Nachricht senden, eine Datenbank abfragen, eine externe API aufrufen und so weiter.

Möglich wird dies mit Werkzeugaufruf. Der Werkzeugaufruf verwandelt einen LLM von einem sehr intelligenten Textgenerator in etwas, das tatsächlich Aktionen auslösen und mit der Welt um ihn herum interagieren kann.

Additionally schauen wir mal rein!

---

Was ist Software Calling?

Werkzeugaufruf (auch genannt Funktionsaufruf) ist der Mechanismus, mit dem ein LLM im Rahmen der Generierung seiner Antwort die Ausführung externer Funktionen oder APIs anfordern kann. Mit anderen Worten: Anstatt nur Textual content zurückzugeben, kann das Modell eine bestimmte Funktion mit bestimmten Argumenten als Antwort auf die Anfrage des Benutzers ausführen.

Das Wichtigste, was es hier zu verstehen gilt, ist Folgendes Das Modell selbst führt das Werkzeug nicht aus. Es nur entscheidet welches Software aufgerufen werden soll und mit welchen Argumenten. Die eigentliche Ausführung des ausgewählten Instruments erfolgt in unserem eigenen Code, in dem die Anfrage an das KI-Modell enthalten ist. Anschließend geben wir das Ergebnis des Instruments an das KI-Modell zurück, das daraus eine endgültige Antwort an den Benutzer generiert.

Dies ist die Werkzeugaufrufschleife, die die folgenden Schritte umfasst:

• Der Benutzer sendet eine Nachricht
• Das KI-Modell nimmt die Nachricht als Eingabe und erzeugt eine Ausgabe, bei der es sich im Wesentlichen um die Entscheidung darüber handelt, welches Software mit welchen Argumenten verwendet werden soll
• Die Antwort des Modells, die die Werkzeugauswahl und die jeweiligen zu verwendenden Argumente enthält, wird an den Code zurückgegeben. Der Code führt – ohne Beteiligung des KI-Modells – das ausgewählte Software mit den ausgewählten Argumenten aus. Diese Ausführung erzeugt ein Ergebnis (z. B. eine Berechnung, von einer API erhaltene Informationen usw.), und dieses Ergebnis wird dann an das KI-Modell zurückgegeben.
• Das KI-Modell verwendet als Eingabe das Ergebnis des Instruments und erstellt darauf basierend eine endgültige Antwort an den Benutzer.

Auch hier generiert das Modell einen Werkzeugaufruf, keine Werkzeugausführung. Die beiden Dinge sind sehr unterschiedlich und ihre Vermischung ist eine der häufigsten Ursachen für Verwirrung.

Aber was genau ist ein Software-Aufruf? In der Praxis bedeutet dies, dass das Modell mithilfe von Funktionsaufrufen eine strukturierte, maschinenlesbare Antwort zurückgibt, wie wir im vorherigen Beitrag gesehen haben. In dieser Antwort ist Inhalt None; Es gibt keine Antwort in natürlicher Sprache, sondern lediglich eine strukturierte Anweisung, die angibt, welches Software mit welchen Argumenten aufgerufen werden soll. Erst nachdem wir das Software ausgeführt und das Ergebnis zurückgegeben haben, generiert das Modell eine tatsächliche Textantwort für den Benutzer.

Aber schauen wir uns das mal in der Praxis an!

---

Wir beginnen mit einem einfachen Beispiel mit nur einem Software und einem Aufruf und bauen dann schrittweise auf einige interessantere Szenarien auf.

1. Ein einziges Software: Wetter-API

Ich denke, das häufigste Beispiel für die Verwendung von Instruments mit KI, das mir in den Sinn kommt, ist eine Wetter-API (der Grundstein für benutzerdefinierte Reside-Daten). Stellen wir uns additionally vor, wir entwickeln einen Wetterassistenten. Insbesondere möchten wir einen Mechanismus schaffen, bei dem der Benutzer nach dem Wetter fragt, und anstatt das KI-Modell einfach etwas erfinden zu lassen (was das Modell sehr gerne tun würde ), möchten wir, dass es eine echte Wetterfunktion aufruft und tatsächliche Daten über das Wetter von irgendwo anders außerhalb des LLM erhält. Um die Wetterdaten zu erhalten, werde ich verwenden Open-Meteoeine kostenlose Open-Supply-Wetter-API, die erfreulicherweise keinen API-Schlüssel erfordert.

Um ein Software verwenden zu können, müssen wir es zunächst in deklarieren instruments.

from openai import OpenAI
import json

shopper = OpenAI(api_key="your_api_key")

# Step 1: outline the software
instruments = (
    {
        "kind": "operate",
        "operate": {
            "identify": "get_current_weather",
            "description": "Get the present climate for a given metropolis",
            "parameters": {
                "kind": "object",
                "properties": {
                    "metropolis": {
                        "kind": "string",
                        "description": "The identify of town, e.g. Athens"
                    },
                    "unit": {
                        "kind": "string",
                        "enum": ("celsius", "fahrenheit"),
                        "description": "The temperature unit to make use of"
                    }
                },
                "required": ("metropolis")
            }
        }
    }
)

Beachten Sie, dass das tatsächlich zu verwendende Software (die Wetter-API) bisher nirgendwo erwähnt wird. Stattdessen entscheidet das Modell anhand von drei Dingen, welches Software aufgerufen werden soll: der Funktionsbeschreibung („Erhalten Sie das aktuelle Wetter für eine bestimmte Stadt“), die Parameterbeschreibungen („Der Title der Stadt, z. B. Athen“) und das erzwungene Schema. Allein anhand dieser Informationen findet das Modell heraus, ob und mit welchen Argumenten dies das richtige Software ist, um eine bestimmte Benutzernachricht aufzurufen. Daher ist das Verfassen klarer und genauer Beschreibungen bei der Definition unserer Instruments von entscheidender Bedeutung, damit das Modell das richtige Software basierend auf den Eingaben des Benutzers erfolgreich identifizieren und aufrufen kann.

Nachdem wir additionally die Instruments-Variable definiert haben, können wir eine Anfrage an das KI-Modell stellen:

# Step 2: ship the person message together with the software definition
messages = (
    {"function": "person", "content material": "What is the climate like in Athens proper now?"}
)

response = shopper.chat.completions.create(
    mannequin="gpt-4o-mini",
    instruments=instruments,
    messages=messages
)

print(response.selections(0).message)

Folgendes passiert, wenn wir diese Anfrage stellen. Das Modell liest die Nachricht des Benutzers, „Wie ist das Wetter gerade in Athen?“und versteht, dass das verfügbare Software get_current_weather kann helfen, diese Frage mit echten Reside-Daten zu beantworten. Anstatt additionally direkt eine Textantwort zu generieren, wird beschlossen, zuerst das Software aufzurufen. Genauer gesagt sieht die Reaktion des Modells zu diesem Zeitpunkt wie folgt aus:

ChatCompletionMessage(
    content material=None,
    function='assistant',
    tool_calls=(
        ChatCompletionMessageToolCall(
            id='call_abc123',
            kind='operate',
            operate=Operate(
                identify='get_current_weather',
                arguments='{"metropolis": "Athens", "unit": "celsius"}'
            )
        )
    )
)

Beachten Sie, wie der Inhalt ist Noneda das Modell keine Textantwort zurückgibt, sondern ein Software-Aufruf. Jetzt ist es unsere Aufgabe, das Werkzeug tatsächlich auszuführen, das Modell auszuwählen und das Ergebnis an dieses zurückzugeben. In unserem Fall wird dazu die API-Anfrage an die Wetter-API gestellt und dabei die Argumente (d. h. die Stadt und die Maßeinheit) verwendet, die in der Antwort des KI-Modells bereitgestellt werden:

# Step 3: execute the software utilizing the Open-Meteo API
import requests

def get_current_weather(metropolis: str, unit: str = "celsius"):
    # geocode town identify to coordinates
    geo = requests.get(
        "https://geocoding-api.open-meteo.com/v1/search",
        params={"identify": metropolis, "rely": 1}
    ).json()
    lat = geo("outcomes")(0)("latitude")
    lon = geo("outcomes")(0)("longitude")

    # fetch present climate
    climate = requests.get(
        "https://api.open-meteo.com/v1/forecast",
        params={
            "latitude": lat,
            "longitude": lon,
            "present": "temperature_2m,weather_code",
            "temperature_unit": unit
        }
    ).json()

    temp = climate("present")("temperature_2m")
    return {"metropolis": metropolis, "temperature": temp, "unit": unit}

# extract the software name from the response
tool_call = response.selections(0).message.tool_calls(0)
arguments = json.masses(tool_call.operate.arguments)

# name the precise operate
weather_result = get_current_weather(**arguments)

Anschließend können wir das Ergebnis des Instruments an den Nachrichtenverlauf anhängen und dann alles an das Modell zurücksenden:

# Step 4: add the assistant's software name AND the software outcome to the message historical past
messages.append(response.selections(0).message)  # necessary: append the software name first
messages.append({
    "function": "software",
    "tool_call_id": tool_call.id,  # hyperlinks the outcome again to the precise software name
    "content material": json.dumps(weather_result)
})

# Step 5: ship every part again to the mannequin for a closing response
final_response = shopper.chat.completions.create(
    mannequin="gpt-4o-mini",
    instruments=instruments,
    messages=messages
)

print(final_response.selections(0).message.content material)

Und jetzt bekommen wir endlich eine richtige Textantwort:

It is presently 29°C in Athens. Feels like an important day to be outdoors!

---

DataCream ist ein Publication mit Geschichten und Tutorials zu KI, Daten und Technologie. Wenn Sie sich für diese Themen interessieren, Abonnieren Sie hier!

---

2. Das Modell aus mehreren Werkzeugen auswählen lassen

Schauen wir uns nun ein realistischeres Beispiel an. In einer realen Agentenanwendung hat das Modell normalerweise Zugriff auf nicht nur einen, sondern mehrere Daher muss anhand der Anforderungen des Benutzers ermittelt werden, welche Instruments verwendet werden müssen.

Erweitern wir unser erstes Wetter-API-Beispiel, indem wir ein zusätzliches Software für Währungen hinzufügen. Dafür verwenden wir Frankfurtereine Währungs-API, die Tageskurse der Europäischen Zentralbank bereitstellt, wiederum ohne API-Schlüssel-Anforderung. Additionally, lasst uns unsere aktualisieren instruments variabel durch Hinzufügen eines zweiten Instruments zur Währungsumrechnung:

instruments = (
    {
        "kind": "operate",
        "operate": {
            "identify": "get_current_weather",
            "description": "Get the present climate for a given metropolis",
            "parameters": {
                "kind": "object",
                "properties": {
                    "metropolis": {"kind": "string", "description": "The identify of town"},
                    "unit": {"kind": "string", "enum": ("celsius", "fahrenheit")}
                },
                "required": ("metropolis")
            }
        }
    },
    {
        "kind": "operate",
        "operate": {
            "identify": "convert_currency",
            "description": "Convert an quantity from one foreign money to a different",
            "parameters": {
                "kind": "object",
                "properties": {
                    "quantity": {"kind": "quantity", "description": "The quantity to transform"},
                    "from_currency": {"kind": "string", "description": "The supply foreign money code, e.g. USD"},
                    "to_currency": {"kind": "string", "description": "The goal foreign money code, e.g. EUR"}
                },
                "required": ("quantity", "from_currency", "to_currency")
            }
        }
    }
)

Und auch das eigentliche einrichten convert_currency Funktion mit der Frankfurter API:

def convert_currency(quantity: float, from_currency: str, to_currency: str):
    response = requests.get(
        f"https://api.frankfurter.dev/v2/charge/{from_currency}/{to_currency}"
    ).json()

    charge = response("charge")
    transformed = spherical(quantity * charge, 2)
    return {
        "quantity": quantity,
        "from_currency": from_currency,
        "to_currency": to_currency,
        "converted_amount": transformed,
        "charge": charge
    }

Auf diese Weise kann das Modell ein viel größeres Spektrum an Benutzeranfragen verarbeiten; Es kann jetzt zusätzlich zum Wetter auch Fragen zu Währungen beantworten . Nun, wenn der Benutzer fragt „Wie ist das Wetter in Athen?“sollte das Modell aufrufen get_current_weather. Wenn sie fragen „Wie viel sind 100 USD in EUR?“es sollte anrufen convert_currency. Und wenn wir etwas fragen, das weder für das Wetter noch für Währungen related ist und bei dem keines der verfügbaren Instruments weiterhelfen kann, antwortet das Modell einfach in Textform, ohne überhaupt ein Software aufzurufen.

Aber sehen wir uns das in Aktion an:

messages = (
    {"function": "person", "content material": "How a lot is 200 USD in EUR?"}
)

response = shopper.chat.completions.create(
    mannequin="gpt-4o-mini",
    instruments=instruments,
    messages=messages
)

tool_call = response.selections(0).message.tool_calls(0)

Werfen wir einen Blick auf die Antwort:

print(tool_call.operate.identify)        

von dem wir bekommen convert_currency. Das Modell verstand additionally, dass die Frage „Wie viel sind 200 USD in EUR?“ ist related für die convert_currency Werkzeug. Werfen wir auch einen Blick auf die Argumente:

print(tool_call.operate.arguments)  

von dem wir bekommen

'{"quantity": 200, "from_currency": "USD", "to_currency": "EUR"}'

Das Modell identifiziert additionally korrekt convert_currency als das richtige Werkzeug und trägt die entsprechenden Argumente ein, ohne dass wir etwas anderes tun müssen, als entsprechende Werkzeugbeschreibungen bereitzustellen und dem Benutzer eine entsprechende Nachricht zu übermitteln. Dieser genaue Entscheidungsmechanismus macht Software-Calling zur Grundlage von Agentensystemen.

3. Mehrere Instruments gleichzeitig aufrufen

Ein weiteres interessantes Software-Aufrufszenario besteht darin, dass viele Modelle wie gpt-4okann mehrere Instruments in einer einzigen Antwort aufrufen, wenn die Anfrage des Benutzers dies erfordert. Dies ist bekannt als paralleler Werkzeugaufruf.

Stellen wir uns zum Beispiel ein Szenario vor, in dem der Benutzer in einer einzigen Anfrage etwas fragt, das die Verwendung beider erfordert get_current_weather Und convert_currency Instruments, um die erforderlichen Informationen zu erhalten:

messages = (
    {"function": "person", "content material": "What is the climate in Athens and the way a lot is 100 USD in EUR?"}
)

response = shopper.chat.completions.create(
    mannequin="gpt-4o-mini",
    instruments=instruments,
    messages=messages
)

for tool_call in response.selections(0).message.tool_calls:
    print(tool_call.operate.identify)
    print(tool_call.operate.arguments)

In diesem Fall erhalten wir folgende Antwort:

get_current_weather
{"metropolis": "Athens"}

convert_currency
{"quantity": 100, "from_currency": "USD", "to_currency": "EUR"}

Beachten Sie, wie beide Instruments in einer einzigen Modellantwort aufgerufen werden. Anschließend können wir die jeweiligen Instruments mit den bereitgestellten Argumenten ausführen und die Software-Ergebnisse gemeinsam an das Modell zurückgeben. Dies ist viel effizienter als sequentielle Aufrufe und ist die Artwork und Weise, wie fortgeschrittenere Agenten mehrteilige Anfragen verarbeiten.

---

In meinen Gedanken: Was macht diesen Agenten aus?

Eine Sache, die mir immer auf die Nerven gegangen ist, ist der Begriff „Agent“, der auf alles geschoben wird. Agenten, Agenten-Workflows, alles, was aus dem Wort hervorgeht Agent ist heutzutage sehr attractive, aber wie Sie vielleicht schon selbst herausgefunden haben, ist nicht alles, was als Agent verkauft wird, wirklich attractive.

Machen wir additionally einen Schritt zurück und denken wir darüber nach, was ein Agent überhaupt ist. Im Kern ist ein Agent etwas, das seine Umgebung wahrnimmt, diese Informationen auf irgendeine Weise verarbeitet, ein Ziel hat und dann entscheidet, welche Maßnahmen es ergreifen muss, um dieses Ziel zu erreichen. Denken Sie darüber nach, was unser Software-Aufrufmechanismus tut: Er erkennt die verfügbaren Instruments, entscheidet, welches für die Anfrage des Benutzers (falls vorhanden) geeignet ist, und gibt diese Entscheidung zur Ausführung an den Relaxation des Codes weiter. Das ist in seiner einfachsten Kind Handlungsfreiheit.

In realen Agentenanwendungen wird die Software-Aufrufschleife nicht nur einmal, sondern mehrere Male ausgeführt, wobei das Modell anhand der Ergebnisse eines Software-Aufrufs entscheidet, ob und welches Software als nächstes aufgerufen werden soll. Dies wird manchmal als a bezeichnet ReAct-Schleife (Grund + Handeln) und ermöglicht es Agenten, komplexe, mehrstufige Aufgaben zu bewältigen, die nicht in einem einzigen Anruf gelöst werden können.

Letztendlich finde ich am Software-Calling am faszinierendsten, wie es die Natur dessen, was ein LLM ist, verändert. Bis zu diesem Zeitpunkt conflict ein Sprachmodell im Wesentlichen ein sehr ausgefeilte Eingabe-Ausgabe-Funktion, die Textual content als Eingabe verwendet und Textual content als Ausgabe generiert. Aber mit dem Software-Aufruf erhalten wir Zugriff auf eine endlose Sammlung zusätzlicher Funktionalitäten, die wir mit der Argumentationsleistung des LLM kombinieren können, um Systeme zu schaffen, die weitaus leistungsfähiger sind als beide allein.

Danke fürs Lesen!

---

Wenn du es bis hierher geschafft hast, Vielleicht finden Sie Pialgorithmen nützlich – eine von uns entwickelte Plattform, die Groups dabei hilft, organisatorisches Wissen sicher an einem Ort zu verwalten.

---

Hat Ihnen dieser Beitrag gefallen? Begleiten Sie mich Unterstapel und LinkedIn

---

Alle Bilder vom Autor, sofern nicht anders angegeben.

Stellen Sie sich vor, Sie fragen Ihr KI-Modell: „Wie ist das Wetter gerade in Tokio?“ und anstatt eine Antwort zu halluzinieren, ruft es Ihre tatsächliche Antwort auf Python-Funktionruft Dwell-Daten ab und antwortet korrekt. So wirkungsvoll sind die Device-Name-Funktionen im Gemma 4 von Google. Eine wirklich spannende Ergänzung zur Open-Weight-KI: Dieser Funktionsaufruf ist strukturiert, zuverlässig und direkt in das KI-Modell integriert!

In Verbindung mit Ollama zur lokalen Referenzierung können Sie damit nicht cloudabhängige KI-Agenten entwickeln. Das Beste daran: Diese Agenten haben lokal und ohne Abonnement Zugriff auf reale APIs und Dienste. In diesem Leitfaden behandeln wir das Konzept und die Implementierungsarchitektur sowie drei Aufgaben, mit denen Sie sofort experimentieren können.

Lesen Sie auch: Claude Code kostenlos mit Gemma 4 und Ollama ausführen

Konversationssprachmodelle verfügen je nach Zeitpunkt ihrer Entwicklung nur über begrenzte Kenntnisse. Sie können daher nur eine ungefähre Antwort geben, wenn Sie nach aktuellen Marktpreisen oder aktuellen Wetterbedingungen fragen. Dieser Mangel wurde durch die Bereitstellung eines API-Wrappers für gängige Modelle (Funktionen) behoben. Das Ziel besteht darin, diese Artwork von Fragen über (toolaufrufende) Dienste zu lösen.

Durch die Aktivierung des Device-Aufrufs kann das Modell Folgendes erkennen:

• Wenn es notwendig ist, externe Informationen abzurufen
• Identifizieren Sie die richtige Funktion anhand der bereitgestellten API
• Korrekt formatierte Methodenaufrufe kompilieren (mit Argumenten)

Anschließend wird gewartet, bis die Ausführung dieses Codeblocks die Ausgabe zurückgibt. Anschließend wird auf der Grundlage der erhaltenen Ausgabe eine bewertete Antwort verfasst.

Zur Verdeutlichung: Das Modell führt niemals die vom Benutzer erstellten Methodenaufrufe aus. Es bestimmt lediglich, welche Methoden aufgerufen werden sollen und wie die Liste der Methodenaufrufargumente strukturiert werden soll. Der Code des Benutzers führt die Methoden aus, die er über die API-Funktion aufgerufen hat. In diesem Szenario stellt das Modell das Gehirn eines Menschen dar, während die aufgerufenen Funktionen die Hände darstellen.

Bevor Sie mit dem Schreiben von Code beginnen, ist es hilfreich zu verstehen, wie alles funktioniert. Hier ist die Schleife, der jedes Werkzeug in Gemma 4 folgt, wenn es Werkzeugaufrufe durchführt:

1. Definieren Sie Funktionen in Python, um tatsächliche Aufgaben auszuführen (z. B. Wetterdaten aus einer externen Quelle abrufen, eine Datenbank abfragen, Geld von einer Währung in eine andere umrechnen).
2. Erstellen Sie ein JSON-Schema für jede der von Ihnen erstellten Funktionen. Das Schema sollte den Namen der Funktion und ihre Parameter (einschließlich ihrer Typen) enthalten.
3. Wenn das System eine Nachricht an Sie sendet, senden Sie sowohl die von Ihnen erstellten Device-Schemata als auch die Nachricht des Programs an die Ollama-API.
4. Die Ollama-API gibt Daten in einem tool_calls-Block und nicht in reinem Textual content zurück.
5. Sie führen die Funktion mithilfe der Parameter aus, die Ihnen von der Ollama-API gesendet werden.
6. Sie geben das Ergebnis als „function“:„instrument“-Antwort an die Ollama-API zurück.
7. Die Ollama-API empfängt das Ergebnis und gibt Ihnen die Antwort in natürlicher Sprache zurück.

Dieses Zwei-Durchlauf-Muster ist die Grundlage für jeden Funktionsaufruf KI-Agenteinschließlich der unten gezeigten Beispiele.

Um diese Aufgaben auszuführen, benötigen Sie zwei Komponenten: Ollama muss lokal auf Ihrem Pc installiert sein und Sie müssen das Gemma 4 Edge 2B-Modell herunterladen. Es gibt keine Abhängigkeiten, die über das hinausgehen, was mit der Standardinstallation von Python bereitgestellt wird, sodass Sie sich überhaupt keine Gedanken über die Set up von Pip-Paketen machen müssen.

1. So installieren Sie Ollama mit Homebrew oder MacOS:

# Set up Ollama (macOS/Linux) 
curl --fail -fsSL https://ollama.com/set up.sh | sh 

2. So laden Sie das Modell herunter (ca. 2,5 GB):

# Obtain the Gemma 4 Edge Mannequin – E2B 
ollama pull gemma4:e2b

Nachdem Sie das Modell heruntergeladen haben, verwenden Sie die Ollama-Liste, um zu bestätigen, dass es in der Modellliste vorhanden ist. Sie können jetzt unter der URL http://localhost:11434 eine Verbindung zur laufenden API herstellen und mithilfe der von uns erstellten Hilfsfunktion Anfragen an diese ausführen:

import json, urllib.request, urllib.parse
def call_ollama(payload: dict) -> dict:
    information = json.dumps(payload).encode("utf-8")
    req = urllib.request.Request(
        "http://localhost:11434/api/chat",
        information=information,
        headers={"Content material-Sort": "utility/json"},
    )
    with urllib.request.urlopen(req) as resp:
        return json.hundreds(resp.learn().decode("utf-8"))

Es sind keine Bibliotheken von Drittanbietern erforderlich. Daher kann der Agent unabhängig ausgeführt werden und bietet vollständige Transparenz.

Lesen Sie auch: So führen Sie Gemma 4 auf Ihrem Telefon aus: Eine praktische Anleitung

Praktische Aufgabe 01: Dwell-Wettersuche

Die erste unserer Methoden verwendet Open-Meteo, das Dwell-Daten für jeden Standort über eine kostenlose Wetter-API abruft, die keinen Schlüssel benötigt, um die Informationen basierend auf Längen-/Breitenkoordinaten auf den lokalen Bereich zu übertragen. Wenn Sie diese API verwenden möchten, müssen Sie eine Reihe von Schritten ausführen:

1. Schreiben Sie Ihre Funktion in Python

def get_current_weather(metropolis: str, unit: str = "celsius") -> str:
    geo_url = f"https://geocoding-api.open-meteo.com/v1/search?identify={urllib.parse.quote(metropolis)}&rely=1"
    with urllib.request.urlopen(geo_url) as r:
        geo = json.hundreds(r.learn())
    loc = geo("outcomes")(0)
    lat, lon = loc("latitude"), loc("longitude") 
    url = (f"https://api.open-meteo.com/v1/forecast"
           f"?latitude={lat}&longitude={lon}"
           f"&present=temperature_2m,wind_speed_10m"
           f"&temperature_unit={unit}")
    with urllib.request.urlopen(url) as r:
        information = json.hundreds(r.learn())
    c = information("present")
    return f"{metropolis}: {c('temperature_2m')}°, wind {c('wind_speed_10m')} km/h" 

2. Definieren Sie Ihr JSON-Schema

Dadurch werden dem Modell die Informationen bereitgestellt, sodass Gemma 4 genau weiß, was die Funktion tun/erwarten wird, wenn sie aufgerufen wird.

 weather_tool = { 

    "kind": "operate",
    "operate": {
        "identify": "get_current_weather",
        "description": "Get stay temperature and wind pace for a metropolis.",
        "parameters": {
            "kind": "object",
            "properties": {
                "metropolis": {"kind": "string", "description": "Metropolis identify, e.g. Mumbai"},
                "unit": {"kind": "string", "enum": ("celsius", "fahrenheit")}
            },
            "required": ("metropolis")
        }
    }

3. Erstellen Sie eine Abfrage für Ihren Device-Aufruf (und bearbeiten und verarbeiten Sie die Antwort zurück).

messages = ({"function": "person", "content material": "What is the climate in Mumbai proper now?"}) response = call_ollama({"mannequin": "gemma4:e2b", "messages": messages, "instruments": (weather_tool), "stream": False}) msg = response("message")
if "tool_calls" in msg: tc = msg("tool_calls")(0) fn = tc("operate")("identify") args = tc("operate")("arguments") consequence = get_current_weather(**args) # executed domestically
messages.append(msg) 
messages.append({"function": "instrument", "content material": consequence, "identify": fn})
remaining = call_ollama({"mannequin": "gemma4:e2b", "messages": messages, "instruments": (weather_tool), "stream": False}) 
print(remaining("message")("content material"))

Ausgabe

Praktische Aufgabe 02: Dwell-Währungsumrechner

Das klassische LLM scheitert daran, dass Währungswerte halluziniert werden und keine genaue, aktuelle Währungsumrechnung möglich ist. Mit Hilfe der ExchangeRate-API kann der Konverter die neuesten Wechselkurse abrufen und genau zwischen zwei Währungen umrechnen.

Sobald Sie die Schritte 1–3 unten abgeschlossen haben, verfügen Sie über einen voll funktionsfähigen Konverter in Gemma 4:

1. Schreiben Sie Ihre Python-Funktion

def convert_currency(quantity: float, from_curr: str, to_curr: str) -> str:
    url = f"https://open.er-api.com/v6/newest/{from_curr.higher()}"
    with urllib.request.urlopen(url) as r:
        information = json.hundreds(r.learn())
    fee = information("charges").get(to_curr.higher())
    if not fee:
        return f"Foreign money {to_curr} not discovered."
    transformed = spherical(quantity * fee, 2)
    return f"{quantity} {from_curr.higher()} = {transformed} {to_curr.higher()} (fee: {fee})"

2. Definieren Sie Ihr JSON-Schema

currency_tool = { 

    "kind": "operate",
    "operate": {
        "identify": "convert_currency",
        "description": "Convert an quantity between two currencies at stay charges.",
        "parameters": {
            "kind": "object",
            "properties": {
                "quantity":    {"kind": "quantity", "description": "Quantity to transform"},
                "from_curr": {"kind": "string", "description": "Supply foreign money, e.g. USD"}, 
                "to_curr":   {"kind": "string", "description": "Goal foreign money, e.g. EUR"}
            },
            "required": ("quantity", "from_curr", "to_curr")
        } 
    }
} 

3. Testen Sie Ihre Lösung mithilfe einer Abfrage in natürlicher Sprache

response = call_ollama({
    "mannequin": "gemma4:e2b",
    "messages": ({"function": "person", "content material": "How a lot is 5000 INR in USD right this moment?"}),
    "instruments": (currency_tool),
    "stream": False
}) 

Gemma 4 verarbeitet die Abfrage in natürlicher Sprache und formatiert einen ordnungsgemäßen API-Aufruf basierend auf Betrag = 5000, von = „INR“ bis = „USD“. Der resultierende API-Aufruf wird dann von derselben „Suggestions“-Methode verarbeitet, die in Aufgabe 01 beschrieben wurde.

Ausgabe

Gemma 4 meistert diese Aufgabe hervorragend. Sie können dem Modell mehrere Instruments gleichzeitig bereitstellen und eine zusammengesetzte Abfrage senden. Das Modell koordiniert alle erforderlichen Anrufe auf einmal; Eine manuelle Verkettung ist nicht erforderlich.

1. Fügen Sie das Zeitzonen-Device hinzu

def get_current_time(metropolis: str) -> str: 

    url = f"https://timeapi.io/api/Time/present/zone?timeZone=Asia/{metropolis}"
    with urllib.request.urlopen(url) as r:
        information = json.hundreds(r.learn())
    return f"Present time in {metropolis}: {information('time')}, {information('dayOfWeek')} {information('date')}"
time_tool = {
    "kind": "operate",
    "operate": {
        "identify": "get_current_time",
        "description": "Get the present native time in a metropolis.",
        "parameters": {
            "kind": "object",
            "properties": {
                "metropolis": {"kind": "string", "description": "Metropolis identify for timezone, e.g. Tokyo"}
            },
            "required": ("metropolis")
        }
    } 

2. Erstellen Sie die Multitool-Agentenschleife

TOOL_FUNCTIONS = { "get_current_weather": get_current_weather, "convert_currency": convert_currency, "get_current_time": get_current_time, } 

def run_agent(user_query: str): all_tools = (weather_tool, currency_tool, time_tool) messages = ({"function": "person", "content material": user_query}) 

response = call_ollama({"mannequin": "gemma4:e2b", "messages": messages, "instruments": all_tools, "stream": False}) 
msg = response("message") 
messages.append(msg) 
 
if "tool_calls" in msg: 
    for tc in msg("tool_calls"): 
        fn     = tc("operate")("identify") 
        args   = tc("operate")("arguments") 
        consequence = TOOL_FUNCTIONS(fn)(**args) 
        messages.append({"function": "instrument)))", "content material": consequence, "identify": fn}) 
 
    remaining = call_ollama({"mannequin": "gemma4:e2b", "messages": messages, "instruments": all_tools, "stream": False}) 
    return remaining("message")("content material")
return msg.get("content material", "")

3. Führen Sie eine zusammengesetzte/Multi-Intent-Abfrage aus

print(run_agent(
    "I am flying to Tokyo tomorrow. What is the present time there, "
    "the climate, and the way a lot is 10000 INR in JPY?"
))e

Ausgabe

Hier haben wir drei unterschiedliche Funktionen mit drei separaten APIs in Echtzeit durch Verarbeitung natürlicher Sprache unter Verwendung eines gemeinsamen Konzepts beschrieben. Es umfasst die gesamte lokale Ausführung ohne Cloud-Lösungen von der Gemma 4-Instanz; Keine dieser Komponenten nutzt Distant-Ressourcen oder eine Cloud.

Was unterscheidet Gemma 4 für Agentic AI?

Andere Modelle mit offenem Gewicht können Werkzeuge aufrufen, funktionieren jedoch nicht zuverlässig, und das ist es, was sie von Gemma 4 unterscheidet. Das Modell bietet durchweg Gültigkeit JSON-Argumenteverarbeitet optionale Parameter korrekt und bestimmt, wann Wissen zurückgegeben und kein Device aufgerufen werden soll. Beachten Sie bei der weiteren Verwendung Folgendes:

• Die Qualität des Schemas ist von entscheidender Bedeutung. Wenn Ihr Beschreibungsfeld vage ist, fällt es Ihnen schwer, Argumente für Ihr Device zu identifizieren. Seien Sie bei Einheiten, Formaten und Beispielen genau.
• Das erforderliche Array wird von Gemma 4 validiert. Gemma 4 berücksichtigt die Unterscheidung zwischen erforderlich und elective.
• Sobald das Device ein Ergebnis zurückgibt, wird dieses Ergebnis zu einem Kontext für eine der „Rollen“: „Device“-Nachrichten, die Sie während Ihres letzten Durchgangs senden. Je umfangreicher das Ergebnis des Instruments ist, desto umfangreicher wird die Antwort sein.
• Ein häufiger Fehler besteht darin, das Device-Ergebnis als „function“: „person“ statt als „function“: „instrument“ zurückzugeben, da das Modell es nicht korrekt zuordnet und versucht, den Aufruf erneut anzufordern.

Lesen Sie auch: Prime 10 Gemma 4-Projekte, die Sie umhauen werden

Abschluss

Sie haben einen echten KI-Agenten erstellt, der die Funktionsaufruffunktion von Gemma 4 nutzt und vollständig lokal arbeitet. Das agentenbasierte System nutzt alle Komponenten der Architektur in der Produktion. Mögliche nächste Schritte können sein:

• Hinzufügen eines Dateisystem-Instruments, das das Lesen und Schreiben lokaler Dateien bei Bedarf ermöglicht;
• mit a SQL-Datenbank als Mittel zur Durchführung von Datenabfragen in natürlicher Sprache;
• Erstellen eines Speichertools, das Sitzungszusammenfassungen erstellt und auf die Festplatte schreibt und so dem Agenten die Möglichkeit gibt, sich an vergangene Gespräche zu erinnern

Das offene KI-Agenten-Ökosystem entwickelt sich schnell weiter. Die Fähigkeit von Gemma 4, strukturierte Funktionsaufrufe nativ zu unterstützen, bietet Ihnen erhebliche autonome Funktionalität, ohne auf die Cloud angewiesen zu sein. Fangen Sie klein an, erstellen Sie ein funktionierendes System, und die Bausteine ​​für Ihre nächsten Projekte stehen bereit, damit Sie sie miteinander verketten können.