Function Calling und API-Integration
Beherrschen Sie, wie Sie LLMs dazu anleiten, externe Funktionen oder APIs aufzurufen, damit sie mit realen Systemen interagieren können.
Function Calling und API-Integration ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Prompt Engineering-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Prompt Engineering-Kurs umfasst insgesamt 3 Lektionen.
Externe Tools aufrufen
LLMs sind leistungsstark, bewegen sich aber hauptsächlich in einer Textwelt. Was ist, wenn sie Informationen aus der realen Welt benötigen oder Aktionen ausführen müssen?
Function Calling ermöglicht es LLMs, mit externen Tools und APIs zu interagieren. Dadurch wird die Lücke zwischen Sprache und Handlung geschlossen, sodass KI:
- Aktuelle Informationen abrufen kann (Wetter, Aktienkurse)
- Aktionen ausführen kann (E-Mails senden, Termine buchen)
- Mit Datenbanken oder benutzerdefinierten Tools verbunden werden kann
Das eröffnet neue Möglichkeiten für KI-Systeme.
Die Rolle des LLMs: Aufrufe vorschlagen
Wenn Sie Function Calling aktivieren, stellen Sie dem LLM Beschreibungen der verfügbaren Tools (Funktionen) bereit.
Statt direkt zu antworten, kann das LLM entscheiden, dass ein Tool hilfreich ist. Anschließend gibt es einen strukturierten „Vorschlag“ für einen Funktionsaufruf aus, einschließlich des Funktionsnamens und seiner Argumente.
Wichtig: Das LLM führt die Funktion nicht selbst aus. Es teilt Ihrer Anwendung lediglich mit, welche Funktion sie mit welchen Eingaben aufrufen soll.
Ihre Tools definieren
Um Function Calling zu verwenden, müssen Sie Ihre Tools (Funktionen) so definieren, dass das LLM sie verstehen kann. Dazu gehören normalerweise:
- Ein Name für die Funktion (z. B.
get_current_weather) - Eine Beschreibung ihrer Aufgabe (entscheidend dafür, dass das LLM die richtige Funktion auswählt)
- Die von ihr akzeptierten Parameter einschließlich ihrer Typen und Beschreibungen (z. B.
location: string)
Dieses „Schema“ teilt dem LLM alles mit, was es benötigt, um einen gültigen Aufruf vorzuschlagen.
Definition eines Wetter-Tools
Hier sehen Sie eine konzeptionelle Python-Definition für ein Wetter-Tool. Beachten Sie die klare Beschreibung und die Parameter. Diese Definition würden Sie dem LLM zur Verfügung stellen.
Diese Funktion stellt das externe Tool dar, das ein LLM konzeptionell „aufrufen“ würde.
def get_current_weather(location: str, unit: str = "celsius"):
"""
Get the current weather in a given location.
Args:
location (str): The city and state, e.g. "London, UK"
unit (str): The unit of temperature, "celsius" or "fahrenheit"
Returns:
dict: Weather information.
"""
# In a real app, this would call a weather API
if location == "London, UK":
return {"temperature": "15", "unit": unit, "forecast": "cloudy"}
elif location == "New York, USA":
return {"temperature": "20", "unit": unit, "forecast": "sunny"}
else:
return {"temperature": "N/A", "unit": unit, "forecast": "unknown"}
Prompts für Tools formulieren
Damit das LLM Ihre Tools verwendet, muss Ihr Prompt die Absicht des Nutzers klar formulieren. Anschließend entscheidet das LLM, ob ein Tool hilfreich sein kann.
Sie sagen dem LLM nicht ausdrücklich „Rufen Sie get_weather auf“. Stattdessen stellen Sie eine Frage, die dies nahelegt:
- „Wie ist das Wetter in London?“
- „Können Sie morgen einen Termin für mich buchen?“
Ausgestattet mit den Tool-Beschreibungen erkennt das LLM, dass ein Funktionsaufruf erforderlich ist.
Aufrufvorschlag des LLMs
Wenn das LLM entscheidet, ein Tool zu verwenden, gibt es keine direkte Antwort aus. Stattdessen gibt es ein strukturiertes Objekt zurück, typischerweise JSON, das angibt, welche Funktion mit welchen Argumenten aufgerufen werden soll.
Ihre Anwendung analysiert diese Ausgabe anschließend.
Wenn das LLM gefragt wird „Wie ist das Wetter in London?“, könnte es Folgendes vorschlagen:
{
"tool_calls": [
{
"id": "call_abc123",
"function": {
"name": "get_current_weather",
"arguments": "{\"location\": \"London, UK\", \"unit\": \"celsius\"}"
},
"type": "function"
}
]
}Ihre Anwendung führt das Tool aus
Nachdem Ihre Anwendung den Funktionsaufruf des LLMs erhalten hat, übernimmt sie:
- Sie identifiziert die angeforderte Funktion (z. B.
get_current_weather). - Sie extrahiert die Argumente (z. B.
"London, UK"). - Sie führt die eigentliche Python-Funktion in der Umgebung Ihrer Anwendung aus (oder tätigt den API-Aufruf).
Hier findet die Aktion in der „realen Welt“ außerhalb des LLMs statt.
Das LLM verarbeitet die Tool-Ausgabe
Nachdem Ihre Anwendung die Funktion ausgeführt hat, erhält sie ein Ergebnis (z. B. {"temperature": "15", ...}).
Dieses Ergebnis wird zusammen mit dem ursprünglichen Gesprächsverlauf und der Anfrage zum Funktionsaufruf an das LLM zurückgegeben.
Das LLM verwendet diese neuen Informationen anschließend, um eine Antwort in natürlicher Sprache auf die ursprüngliche Anfrage des Nutzers zu formulieren.
Interaktion von Anfang bis Ende
Fügen wir nun alles zusammen. Dieses Beispiel zeigt den Ablauf: Die Frage eines Nutzers veranlasst ein LLM, einen Funktionsaufruf vorzuschlagen, Ihre Anwendung führt ihn aus und das LLM gibt anschließend eine abschließende Antwort.
Dies ist eine vereinfachte Darstellung der Interaktionsschleife.
def get_current_weather(location, unit="celsius"):
if location == "London, UK":
return {"temp": "15", "unit": unit, "forecast": "cloudy"}
return {"temp": "N/A", "unit": unit, "forecast": "unknown"}
def simulate_llm_response(user_query):
# LLM 'thinks' and decides to call a tool
if "weather in London" in user_query:
return {
"type": "tool_call",
"function": "get_current_weather",
"args": {"location": "London, UK"}
}
return {"type": "text", "content": "I cannot help with that."}
def simulate_llm_final_response(tool_output):
# LLM processes tool output and gives natural language
temp = tool_output.get("temp", "N/A")
forecast = tool_output.get("forecast", "unknown")
return f"The weather in London is {temp} degrees and {forecast}."
def main():
user_input = "What is the weather in London, UK?"
print(f"User: {user_input}")
llm_output = simulate_llm_response(user_input)
if llm_output["type"] == "tool_call":
func_name = llm_output["function"]
func_args = llm_output["args"]
print(f"LLM suggested calling: {func_name}({func_args})")
# Execute the function
tool_result = get_current_weather(**func_args)
print(f"Tool output: {tool_result}")
# Feed result back to LLM
final_answer = simulate_llm_final_response(tool_result)
print(f"LLM's final answer: {final_answer}")
else:
print(f"LLM: {llm_output['content']}")
if __name__ == "__main__":
main()
Überprüfung: Function Calling
Stellen Sie sich vor, ein LLM gibt eine Anfrage für einen Funktionsaufruf zurück. Was ist der nächste unmittelbare Schritt, den Ihre Anwendung ausführen sollte?
Zusammenfassung: Tools in Aktion
In dieser Lektion haben wir untersucht, wie LLMs mithilfe von Function Calling und API-Integration mit der realen Welt interagieren können.
Wir haben gelernt:
- Sie definieren Tools (Funktionen) mit Beschreibungen und Parametern.
- Das LLM schlägt vor, welches Tool mit welchen Argumenten aufgerufen werden soll.
- Ihre Anwendung führt das eigentliche Tool aus und gibt das Ergebnis zurück.
- Das LLM verwendet das Ergebnis, um eine abschließende, fundierte Antwort zu formulieren.
Diese leistungsstarke Technik ermöglicht es LLMs, über die reine Textgenerierung hinauszugehen, Aktionen auszuführen und aktuelle Informationen abzurufen.
Häufig gestellte Fragen
Ist die Lektion „Function Calling und API-Integration“ kostenlos?
Ja — der vollständige Text von „Function Calling und API-Integration“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Prompt Engineering-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Prompt Engineering-Kurs umfasst insgesamt 3 Lektionen.
Was lerne ich in „Function Calling und API-Integration“?
Beherrschen Sie, wie Sie LLMs dazu anleiten, externe Funktionen oder APIs aufzurufen, damit sie mit realen Systemen interagieren können. Du übst AI Prompt Engineering mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Prompt Engineering zu starten?
Keine Vorkenntnisse erforderlich. AI Prompt Engineering auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.
Wie lange dauert die Lektion „Function Calling und API-Integration“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Prompt Engineering-Lektion Code schreiben und ausführen?
Ja. Jede AI Prompt Engineering-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Function Calling und API-Integration
- Multi-Agent-Prompting-Systeme
- Benutzerdefinierte Tools und Plugins für LLMs