Gemma 4 Device-Aufruf erklärt: Schritt-für-Schritt-Anleitung

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.