Warum nutzen OpenAI, Claude und Gemini alle unterschiedliche Formate? Gibt es einen Standard?

Gibt es nicht. Jeder Anbieter hat das separat gebaut. **OpenAI** ging als Erstes (2023), nannte es *function calling* und packte es in `{ type: "function", function: {...} }`, weil sie planten, später andere Arten von *"Tools"* hinzuzufügen. **Anthropic** ging minimal: `name`, `description`, `input_schema`. **Google** nahm von Tag eins mehrere Funktionen pro Aufruf an, also packen sie sie in ein `functionDeclarations`-Array. Jeder hat seine eigene Logik, und nichts wird sich in absehbarer Zeit angleichen, genau deshalb sind Konverter wie dieser tatsächlich nützlich.

Was genau sollte in meinem JSON-Schema sein?

Drei Felder, Minimum. **`name`**: der Funktionsbezeichner, ideal snake_case (`get_weather`, `create_user`). **`description`**: ein kurzer Hinweis darauf, **was die Funktion tut**. Dieser ist kritisch: das Modell entscheidet **wann** es die Funktion aufruft, basierend auf dieser Beschreibung. Je konkreter, desto besser (*"Holt das aktuelle Wetter für eine gegebene Stadt"* schlägt *"Wetter-Utility"*). **`parameters`**: ein JSON-Schema (Draft 7) mit `type: "object"`, einer Liste von `properties` (jedes Argument typisiert) und `required` (welche Pflicht sind). Eine gute `description` ist 70 % des Erfolgs: ein Bot, der die Funktion nicht aufruft, die er sollte, hat meist eine vage description.

Warum ruft mein Bot meine Funktion nicht auf, obwohl ich sie verdrahtet habe?

Top fünf Gründe: - **Eins**: ein Bug im Schema (Tippfehler in `type`, kaputtes JSON). Paste es hier, der Validator zeigt es dir. - **Zwei**: die `description` ist zu vage, der Bot weiß nicht, wann er sie feuern soll. Sei spezifisch. - **Drei**: zwei Funktionen überlappen, `get_weather` und `get_forecast` mit ähnlichen descriptions und das Modell kann sich nicht entscheiden. - **Vier**: bei der Anthropic-API hast du `max_tokens` vergessen (das Antwortlängen-Limit), ohne das bekommst du einen Fehler. - **Fünf**: die Frage des Nutzers passt zu keiner Funktion (*"erzähl mir einen Witz"*, der Bot skippt zu Recht `get_weather`).

Wie schreibe ich ein Tool von OpenAI zu Claude um?

Drei Änderungen im Schema und zwei im API-Aufruf. **Im Schema**: lass den `{ type: "function", function: {...} }`-Wrapper weg, Anthropic braucht ihn nicht. Benenn `parameters` zu `input_schema` um. Alles andere bleibt. **Im Aufruf**: nutz `anthropic.messages.create` statt `openai.chat.completions.create`, und füg das erforderliche `max_tokens` hinzu (z. B. 1024). Eins noch: die Function-Call-Antwort des Modells lebt in `response.content` als Block vom Typ `tool_use` (nicht in einem `tool_calls`-Array wie bei OpenAI). Der Konverter erledigt das für dich: paste das OpenAI-Schema, bekomm die Claude-Version plus ein fertiges Snippet mit dem API-Aufruf.

Was generiert der "Code-Sample"-Modus?

Ein fertiges TypeScript-Snippet mit dem **API-Aufruf** für deinen gewählten Anbieter: - **OpenAI**: `openai.chat.completions.create({ model, messages, tools })`. - **Anthropic**: `anthropic.messages.create({ model, messages, tools, max_tokens })`. `max_tokens` ist Pflicht. - **Gemini**: `model.generateContent({ tools: [{ functionDeclarations: [...] }] })`. Du pastest es in deinen Code, tauschst den Modellnamen gegen das, was du nutzt (z. B. 'gpt-4o', 'claude-sonnet-4', 'gemini-2.5-pro') und es funktioniert. Das Snippet hat schon Imports und Antwort-Handling, echte Copy-Paste-Reife.

Kann ich mehrere Funktionen zu einem Bot hinzufügen?

Bei jedem der drei Anbieter: ja. Es ist ein normales Array: `tools: [tool1, tool2, tool3]`. Der Konverter selbst handhabt **eine Funktion zur Zeit** (Input = einzelne Tool-Definition), also konvertier nacheinander und kombinier zu einem Array in deinem Code. **Praktische Anmerkung**: Produktions-Apps haben selten mehr als 8-10 Funktionen in einem System-Prompt. Darüber fängt das Modell an, die richtige zu wählen, und die Qualität fällt. Besser auf ein paar kleinere spezialisierte Bots aufteilen.

Warum nutzt Anthropic `input_schema` statt `parameters`?

Eine Namenswahl, funktional identisch. **OpenAI** sagt *parameters*, *"Funktions-Parameter"*, klassisch, wie in typisierten Sprachen. **Anthropic** wählte *input_schema*, um zu betonen: ein Tool hat einen **Input**, und das Modell gibt einen Function-Call-Block (`tool_use`) zurück, der einen `input` enthält, der zu diesem Schema passt. Geschmackssache und terminologische Konsistenz, ändert nichts an der eigentlichen Logik.

Was ist `max_tokens` und warum verlangt Anthropic es?

`max_tokens` ist die **Obergrenze für die Antwortlänge**, wie viele *"Wort-Stücke"* (Token) der Bot generieren darf, bevor er stoppt. **OpenAI** hat einen sinnvollen Default, der Parameter ist also optional. **Anthropic** verlangt es immer, weil sie keine Annahmen für dich treffen wollen (und dich nicht bei der Rechnung überraschen wollen). Praktische Werte: 1024 für kurze Antworten, 4096 für normale, 8192+ für lange Berichte. Setz es zu niedrig und die Antwort wird mitten im Satz abgeschnitten.

Woher bekomme ich ein JSON-Schema für meine API?

Zwei Wege. **Eins**: wenn deine API eine OpenAPI- (Swagger-) Doku hat, sind die Schemas schon da, jeder Endpoint hat den Request an den Service beschrieben. Du kannst einen ganzen Endpoint nehmen und ihn als Funktion definieren (`POST /users` → `name: "create_user"`). **Zwei**: für eine interne Funktion in deinem Code, schreib das Schema von Hand. Kleiner Tipp: starte mit 1-3 Funktionen, polier ihre descriptions, dann füg mehr hinzu. Einfacher zu debuggen, wenn etwas bricht.

Was genau prüft der Validator?

Drei Dinge: - **Eins**: ist es überhaupt gültiges JSON (häufigster Patzer: fehlendes Komma, ungeschlossene Klammer). - **Zwei**: sind alle Pflichtfelder da (`name`, `description`, `parameters`). - **Drei**: sind die Typen sauber (`name` und `description` Strings, `parameters` ein Objekt). **Wir prüfen nicht** die tiefe JSON-Schema-Korrektheit: Typen in `properties`, `enum`-Werte, Regexes. Das macht die API des Anbieters beim tatsächlichen Aufruf. Der Validator hier fängt 80 % der Tippfehler ab, bevor du eine Anfrage feuerst und für einen kaputten Aufruf zahlst.

Warum packt Gemini alles in `functionDeclarations`?

Weil Google von Tag eins angenommen hat, dass ein *"Tool"* mehr als nur eine Funktion ist. Die volle Gemini-Struktur ist `tools: [{ functionDeclarations: [...] }, { codeExecution: {} }, { googleSearchRetrieval: {} }]`, jedes Element im Array kann ein **anderer Tool-Typ** sein: eine Funktion, Code-Ausführung, eine Google-Suche. **OpenAI** und **Anthropic** gingen ein einfacheres Modell (nur Funktionen/Tools), Google ging breiter. Deshalb endet dein Schema in `functionDeclarations`, das ist nur einer von mehreren möglichen Tool-Typen in ihrem Modell. Der Konverter erledigt dieses Einpacken für dich.

LLM-Tool-Schema-Konverter - kostenlos

Eingabe (JSON Schema)✓ Gültig

Definiere die Funktion als JSON mit den Feldern name, description und parameters.

Zielformat

Ausgabe

{
  "type": "function",
  "function": {
    "name": "get_weather",
    "description": "Get the current weather for a location",
    "parameters": {
      "type": "object",
      "properties": {
        "location": {
          "type": "string",
          "description": "City and country, e.g. 'Warsaw, Poland'"
        },
        "unit": {
          "type": "string",
          "enum": [
            "celsius",
            "fahrenheit"
          ],
          "description": "Temperature unit"
        }
      },
      "required": [
        "location"
      ]
    }
  }
}

OpenAI-Format: Objekt mit type, function (name, description, parameters). Kompatibel mit gpt-4o und neuer.

JSON-Schema zu LLM-Tool-Definition: OpenAI, Claude, Gemini

Du baust eine App, in der der Bot deine Funktion ausführen kann (Wetter prüfen, etwas in einer Datenbank speichern, eine E-Mail senden). Der offizielle Name ist function calling (OpenAI und Google) oder tool use (Anthropic). Um dem Bot zu sagen, was er aufrufen kann, beschreibst du jede Funktion in JSON-Schema, einem Format, das der Bot versteht: *"das ist der Funktionsname, das sind ihre Argumente, das sind die Pflichttypen"*.

Das Problem: jeder Anbieter bleibt bei seinem eigenen Format. OpenAI packt das Schema in `{ type: "function", function: {...} }`. Anthropic nutzt `input_schema` statt `parameters`. Google Gemini stopft alles in ein `functionDeclarations`-Array. Selbes Konzept, drei verschiedene Syntaxen.

Paste dein JSON-Schema einmal, bekomm ready-to-use Definitionen für alle drei Anbieter. Plus ein fertiges TypeScript-Snippet mit dem API-Aufruf (`chat.completions.create`, `messages.create`, `generateContent`), wirf es in deinen Code und du bist fertig.

So nutzt du den Konverter

Paste das JSON-Schema deiner Funktion. Braucht drei Felder: `name` (der Name), `description` (was sie macht) und `parameters` (welche Argumente sie nimmt).

Der Validator prüft das Schema beim Tippen. Grünes OK = alles passt, roter Fehler = wir zeigen genau, was falsch ist.

Wähl den Ziel-Anbieter: OpenAI, Anthropic oder Gemini.

JSON only / Code-Sample-Schalter: das erste gibt dir das nackte Schema, das zweite ein fertiges TypeScript-Snippet mit dem API-Aufruf.

Kopier das Ergebnis. Paste es in deinen Code, in curl, in Postman, wo immer du es brauchst.

Wann das nützlich ist

Sechs typische Situationen, in denen dieser Konverter dir einen konkreten Vorsprung gibt:

Migration von OpenAI zu Claude (oder zu Gemini). Deine App hat 50 Funktionen für GPT-4o definiert, der Kunde will zu Claude wechseln. Statt jedes Schema per Hand umzuschreiben (und Tippfehler zu machen), schickst du sie nacheinander durch den Konverter, fertig.
App, die mehrere Modelle gleichzeitig nutzt. Ein günstiges für einfache Aufgaben, ein teureres für schwere. Jedes braucht das Schema in seinem eigenen Format. Eine Quelle der Wahrheit (dein JSON-Schema) → drei konsistente Versionen am Ausgang.
Junior-Dev lernt function calling. Drei Doku-Sätze lesen dauert eine Stunde, die du nicht hast. Hier siehst du sofort: *"so sieht es bei OpenAI aus, so bei Claude, so bei Gemini"*. Fünf Minuten und du verstehst die Unterschiede.
Schneller Prototyp. Eine Idee für eine Funktion testen. Starte mit OpenAI (günstiger, schneller), funktioniert? Konvertier zu Claude (bessere Qualität bei komplexeren Anfragen). Kein Neuschreiben von Grund auf.
Eine API für Kunden dokumentieren. Du hast eine öffentliche API und willst, dass Kunden sie in ein LLM einbinden können. Du generierst drei Versionen (OpenAI, Anthropic, Gemini) und legst sie in deine Doku, lass die Kunden wählen, was passt.
*"Mein Bot ruft meine Funktion nicht auf"*. Klassisches Junior-Problem. Grund Nr. 1: ein Bug im Schema (Tippfehler in `type`, falsche Verschachtelung, fehlendes Feld). Der Validator hier markiert es sofort, bevor du eine Anfrage an die API schickst und für einen kaputten Aufruf bezahlst.

Fragen und Antworten

Es ist der Mechanismus, der dem Bot erlaubt, deine Funktion auszuführen. Ohne ihn redet das Modell nur, mit ihm kann es etwas tun: Wetter prüfen, in eine DB speichern, eine E-Mail senden, eine Berechnung in deinem System ausführen. Du beschreibst eine Funktion (in JSON-Schema), der Nutzer fragt *"wie ist das Wetter in Berlin?"*, das Modell entscheidet *"okay, ich rufe `get_weather` mit `city: "Berlin"` auf"*, dein Code ruft eine Wetter-API auf, gibt das Ergebnis ans Modell zurück, das Modell formuliert die Antwort in Klartext. OpenAI und Google nennen es *function calling*, Anthropic nennt es *tool use*, dasselbe Ding.

{ "type": "function", "function": { "name": "get_weather", "description": "Get the current weather for a location", "parameters": { "type": "object", "properties": { "location": { "type": "string", "description": "City and country, e.g. 'Warsaw, Poland'" }, "unit": { "type": "string", "enum": [ "celsius", "fahrenheit" ], "description": "Temperature unit" } }, "required": [ "location" ] } } }

JSON-Schema zu LLM-Tool-Definition: OpenAI, Claude, Gemini

So nutzt du den Konverter

Paste das JSON-Schema deiner Funktion. Braucht drei Felder: `name` (der Name), `description` (was sie macht) und `parameters` (welche Argumente sie nimmt).

Der Validator prüft das Schema beim Tippen. Grünes OK = alles passt, roter Fehler = wir zeigen genau, was falsch ist.

Wähl den Ziel-Anbieter: OpenAI, Anthropic oder Gemini.

JSON only / Code-Sample-Schalter: das erste gibt dir das nackte Schema, das zweite ein fertiges TypeScript-Snippet mit dem API-Aufruf.

Kopier das Ergebnis. Paste es in deinen Code, in curl, in Postman, wo immer du es brauchst.

Wann das nützlich ist

Sechs typische Situationen, in denen dieser Konverter dir einen konkreten Vorsprung gibt:

Migration von OpenAI zu Claude (oder zu Gemini). Deine App hat 50 Funktionen für GPT-4o definiert, der Kunde will zu Claude wechseln. Statt jedes Schema per Hand umzuschreiben (und Tippfehler zu machen), schickst du sie nacheinander durch den Konverter, fertig.
App, die mehrere Modelle gleichzeitig nutzt. Ein günstiges für einfache Aufgaben, ein teureres für schwere. Jedes braucht das Schema in seinem eigenen Format. Eine Quelle der Wahrheit (dein JSON-Schema) → drei konsistente Versionen am Ausgang.
Junior-Dev lernt function calling. Drei Doku-Sätze lesen dauert eine Stunde, die du nicht hast. Hier siehst du sofort: *"so sieht es bei OpenAI aus, so bei Claude, so bei Gemini"*. Fünf Minuten und du verstehst die Unterschiede.
Schneller Prototyp. Eine Idee für eine Funktion testen. Starte mit OpenAI (günstiger, schneller), funktioniert? Konvertier zu Claude (bessere Qualität bei komplexeren Anfragen). Kein Neuschreiben von Grund auf.
Eine API für Kunden dokumentieren. Du hast eine öffentliche API und willst, dass Kunden sie in ein LLM einbinden können. Du generierst drei Versionen (OpenAI, Anthropic, Gemini) und legst sie in deine Doku, lass die Kunden wählen, was passt.
*"Mein Bot ruft meine Funktion nicht auf"*. Klassisches Junior-Problem. Grund Nr. 1: ein Bug im Schema (Tippfehler in `type`, falsche Verschachtelung, fehlendes Feld). Der Validator hier markiert es sofort, bevor du eine Anfrage an die API schickst und für einen kaputten Aufruf bezahlst.

Fragen und Antworten

LLM-Tool-Schema-Konverter

JSON-Schema zu LLM-Tool-Definition: OpenAI, Claude, Gemini

So nutzt du den Konverter

Wann das nützlich ist

Fragen und Antworten

Passende Tools

System-Prompt-Generator

LLM-Modell-Vergleicher

LLM-Token-Zähler

LLM-Tool-Schema-Konverter

JSON-Schema zu LLM-Tool-Definition: OpenAI, Claude, Gemini

So nutzt du den Konverter

Wann das nützlich ist

Fragen und Antworten

Passende Tools

System-Prompt-Generator

LLM-Modell-Vergleicher

LLM-Token-Zähler