> ## Documentation Index
> Fetch the complete documentation index at: https://docs.infercom.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Function Calling und JSON-Modus Funktionen implementieren - Entwicklerhandbuch

> Agentische Workflows mit Infercom Function Calling und JSON-Modus. Tools definieren, Funktionsaufrufe verarbeiten und strukturierte Ausgaben erhalten.

Function Calling ermöglicht dynamische Workflows, indem das Modell basierend auf Benutzereingaben Funktionsaufrufe auswählen und vorschlagen kann, was beim Aufbau von agentischen Workflows hilft. Durch die Definition einer Reihe von Funktionen oder Tools stellen Sie einen Kontext bereit, der es dem Modell ermöglicht, Funktionsargumente nach Bedarf zu empfehlen und auszufüllen.

## Wie Function Calling funktioniert

Function Calling ermöglicht adaptive Workflows, die Echtzeitdaten und strukturierte Ausgaben nutzen und so dynamischere und reaktionsfähigere Modellinteraktionen schaffen.

1. **Anfrage mit Tools senden:** Beginnen Sie, indem Sie eine Benutzeranfrage zusammen mit verfügbaren Tools senden, die im JSON-Schema definiert sind. Dieses Schema gibt Parameter für jede Funktion an.
2. **Das Modell verarbeitet und schlägt vor**: Das Modell interpretiert die Anfrage, bewertet die Absicht und entscheidet, ob es konversationell antworten oder Funktionsaufrufe vorschlagen wird. Wenn eine Funktion aufgerufen wird, füllt es die Argumente basierend auf dem Schema aus.
3. **Modellantwort erhalten:** Sie erhalten eine Antwort vom Modell, die einen Funktionsaufrufvorschlag enthalten kann. Führen Sie die Funktion mit den bereitgestellten Argumenten aus und geben Sie das Ergebnis zur weiteren Interaktion an das Modell zurück.

<Aside type="note">
  Nicht alle Modelle unterstützen Function Calling. Siehe [Infercom Inference Service Modelle](/de/models/infercomcloud-models) für die Liste der verfügbaren Modelle und deren Funktionen.
</Aside>

<Aside type="tip">
  Bei Verwendung von `gpt-oss-120b` für Function Calling setzen Sie `reasoning_effort` auf `"high"` für beste Ergebnisse.
</Aside>

## Modellunterstützung

Function Calling wird von den unten aufgeführten Modellen unterstützt. Prüfen Sie stets [Unterstützte Modelle](/de/models/infercomcloud-models) auf die aktuelle Verfügbarkeit.

| **Modell-ID** | **Region** | **Tools** | **Erzwungenes `tool_choice`** | **`response_format`** | **Tools mit Bild** |
| :------------ | :--------- | :-------- | :---------------------------- | :-------------------- | :----------------- |
| `gpt-oss-120b` | EU | Ja | Ja | Ja | Nicht zutreffend - nur Text |
| `gemma-4-31B-it` | EU | Ja | Siehe Warnung unten | Ja | Ja |
| `DeepSeek-V3.1` | Nicht-EU | Ja | Ja | Ja | Nicht zutreffend - nur Text |
| `DeepSeek-V3.2` | Nicht-EU | Ja | Ja | Ja | Nicht zutreffend - nur Text |
| `Meta-Llama-3.3-70B-Instruct` | Nicht-EU | Ja | Ja | Ja | Nicht zutreffend - nur Text |
| `MiniMax-M3` | Nicht-EU | Ja | Ja | Ja | Nicht zutreffend - nur Text |

Vision-Anfragen unterstützen dieselben Optionen `tools`, `tool_choice` und `response_format` wie reine Textanfragen. Die Einschränkung wird während der Generierung angewendet. Siehe [Vision](/de/features/vision#tools-und-strukturierte-ausgabe-mit-bildern).

## Beispielverwendung

Die folgenden Beispiele beschreiben jeden Schritt der Verwendung von Function Calling mit einem End-to-End-Beispiel nach dem letzten Schritt.

### Schritt 1: Funktionsschema definieren

Definieren Sie ein JSON-Schema für Ihre Funktion. Sie müssen Folgendes angeben:

- Den Namen der Funktion.
- Eine Beschreibung dessen, was sie tut.
- Die Parameter, ihre Datentypen und Beschreibungen.

```json title="Example schema for getting the weather"
{
  "type": "function",
  "function": {
    "name": "get_weather",
    "description": "Gets the current weather information for a given city.",
    "parameters": {
      "type": "object",
      "properties": {
        "city": {
          "type": "string",
          "description": "Name of the city to get weather information for."
        }
      },
      "required": ["city"]
    }
  }
}
```

### Schritt 2: Function Calling in Ihrer Anfrage konfigurieren

Fügen Sie beim Senden einer Anfrage die Funktionsdefinition im Parameter `tools` ein und setzen Sie `tool_choice` auf einen der folgenden Werte:

- `auto` : Ermöglicht dem Modell, zwischen der Generierung einer Nachricht oder dem Aufrufen einer Funktion zu wählen. Dies ist die Standard-Tool-Auswahl, wenn das Feld nicht angegeben wird.
- `required` : Dies zwingt das Modell, einen Funktionsaufruf zu generieren. Das Modell wird dann immer eine oder mehrere Funktion(en) zum Aufrufen auswählen.
- Um einen bestimmten Funktionsaufruf zu erzwingen, setzen Sie `tool_choice = {"type": "function", "function": {"name": "get_weather"}}`. Dies stellt sicher, dass das Modell nur die angegebene Funktion verwendet.

<Aside type="caution">
  **Ein erzwungenes `tool_choice` ist nicht bei jedem Modell garantiert.** Planen Sie zwei Verhaltensweisen ein.

  **`gemma-4-31B-it` hält die Einschränkung nicht immer ein.** Bei Prompts, die nicht offensichtlich einen Tool-Aufruf erfordern, liefert etwa ein Drittel bis die Hälfte eine reine Textantwort statt des erzwungenen Aufrufs. Die übrigen Modelle in der Tabelle oben sind nicht betroffen. Wenn Sie einen zuverlässig erzwungenen Aufruf auf Infercoms EU-Infrastruktur benötigen, verwenden Sie `gpt-oss-120b`.

  **Ein nicht eingehaltener erzwungener Aufruf gibt HTTP 400 zurück.** Wenn das Modell keinen gültigen Funktionsaufruf erzeugt, schlägt die Anfrage mit dem folgenden Body fehl. Beachten Sie, dass diese Antwort nicht die standardmäßige Fehlerhülle verwendet: `error` ist ein String, kein Objekt, und es gibt keine `request_id`.

  ```json
  {
    "error": "Specified tool_choice with function name \"book_flight\", but the model output contains zero valid function call.",
    "error_code": null,
    "error_model_output": "I can help you book a flight from Munich to Lisbon...",
    "error_type": "Invalid function calling output."
  }
  ```

  Das Feld `error_model_output` enthält den Text, den das Modell stattdessen erzeugt hat. Lesen Sie es aus, wenn Sie die Antwort dennoch benötigen. Behandeln Sie diesen Status in jedem Workflow, der einen Aufruf erzwingt. Siehe [API-Fehlercodes](/de/api-reference/using-the-api/api-error-codes).
</Aside>

<Aside type="note">
  Der folgende Codeblock zeigt eine gefälschte Wetterabfrage, die eine zufällige Temperatur zwischen 20°C und 50°C zurückgibt. Für genaue und Echtzeitwetterdaten verwenden Sie eine ordnungsgemäße Wetter-API.
</Aside>

<Tabs syncKey="code">
<TabItem label="Python (SambaNova)">

```python
import sambanova
import random
import json

# Initialize the client with the SambaNova base URL and API key
client = sambanova.SambaNova(
    base_url="https://api.infercom.ai/v1",
    api_key="ihr-infercom-api-schluessel"
)

MODEL = 'gpt-oss-120b'

def get_weather(city: str) -> dict:
    """
    Fake weather lookup: returns a random temperature between 20°C and 50°C.
    """
    temp = random.randint(20, 50)
    return {
        "city": city,
        "temperature_celsius": temp
    }

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather of a location, the user should supply a location first",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    }
                },
                "required": ["city"]
            },
        }
    },
]

messages = [{"role": "user", "content": "What's the weather like in Paris today?"}]


completion = client.chat.completions.create(
    model=MODEL,
    messages=messages,
    tools=tools
)

print(completion)
```

</TabItem>
<TabItem label="Python (OpenAI)">

```python
import openai
import random
import json

# Initialize the client with the SambaNova base URL and API key
client = openai.OpenAI(
    base_url="https://api.infercom.ai/v1",
    api_key="ihr-infercom-api-schluessel"
)

MODEL = 'gpt-oss-120b'

def get_weather(city: str) -> dict:
    """
    Fake weather lookup: returns a random temperature between 20°C and 50°C.
    """
    temp = random.randint(20, 50)
    return {
        "city": city,
        "temperature_celsius": temp
    }

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather of a location, the user should supply a location first",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    }
                },
                "required": ["city"]
            },
        }
    },
]

messages = [{"role": "user", "content": "What's the weather like in Paris today?"}]


completion = client.chat.completions.create(
    model=MODEL,
    messages=messages,
    tools=tools
)

print(completion)
```

</TabItem>
</Tabs>

### Schritt 3: Tool-Aufrufe handhaben

Wenn das Modell sich entscheidet, eine Funktion aufzurufen, finden Sie `tool_calls` in der Antwort. Extrahieren Sie die Funktionsaufrufdetails und führen Sie die entsprechende Funktion mit den bereitgestellten Parametern aus.

```python title="Example code"
tool_call = completion.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)

result = get_weather(args["city"])
```

### Schritt 4: Funktionsergebnisse an das Modell zurückgeben

Sobald Sie das Ergebnis berechnet haben, geben Sie es an das Modell zurück, um die Konversation fortzusetzen oder die Ausgabe zu bestätigen.

```python title="Example code"
messages.append(completion.choices[0].message)  # append model's function call message
messages.append({                               # append result message
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": str(result)
})

completion_2 = client.chat.completions.create(
    model=MODEL,
    messages=messages,
 
)
print(completion_2.choices[0].message.content)
```

### Schritt 5: Beispielausgabe

Eine Beispielausgabe wird unten gezeigt.

```
The current weather in Paris is 25 degrees Celsius.
```

### End-to-End-Beispiel

<Aside type="note">
  Der folgende Codeblock zeigt eine gefälschte Wetterabfrage, die eine zufällige Temperatur zwischen 20°C und 50°C zurückgibt. Für genaue und Echtzeitwetterdaten verwenden Sie eine ordnungsgemäße Wetter-API.
</Aside>

<Tabs syncKey="code">
<TabItem label="Python (SambaNova)">

```python
import sambanova
import random
import json

# Define the SambaNova client
client = sambanova.SambaNova(
    base_url="https://api.infercom.ai/v1",
    api_key="ihr-infercom-api-schluessel"
)

MODEL = 'gpt-oss-120b'

def get_weather(city: str) -> dict: 
    """
    Fake weather lookup: returns a random temperature between 20°C and 50°C.
    """
    temp = random.randint(20, 50)
    return {
        "city": city,
        "temperature_celsius": temp
    }


tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather of a location, the user should supply a location first",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    }
                },
                "required": ["city"]
            },
        }
    },
]

messages = [{"role": "user", "content": "What's the weather like in Paris today?"}]


completion = client.chat.completions.create(
    model=MODEL,
    messages=messages,
    tools=tools
)

print(completion)


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

result = get_weather(args["city"])


messages.append({                               # append model's function call message
 "role": "assistant",
 "content": None,
 "tool_calls": [tool_call]
})

messages.append({                               # append result message
 "role": "tool",                           
 "tool_call_id": tool_call.id,
 "content": json.dumps(result)
})

completion_2 = client.chat.completions.create(
    model=MODEL,
    messages=messages,
 
)
print(completion_2.choices[0].message.content)
```

</TabItem>
<TabItem label="Python (OpenAI)">

```python
import openai
import random
import json

# Define the OpenAI client
client = openai.OpenAI(
    base_url="https://api.infercom.ai/v1",
    api_key="ihr-infercom-api-schluessel"
)

MODEL = 'gpt-oss-120b'

def get_weather(city: str) -> dict:
    """
    Fake weather lookup: returns a random temperature between 20°C and 50°C.
    """
    temp = random.randint(20, 50)
    return {
        "city": city,
        "temperature_celsius": temp
    }


tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather of a location, the user should supply a location first",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    }
                },
                "required": ["city"]
            },
        }
    },
]

messages = [{"role": "user", "content": "What's the weather like in Paris today?"}]


completion = client.chat.completions.create(
    model=MODEL,
    messages=messages,
    tools=tools
)

print(completion)


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

result = get_weather(args["city"])


messages.append({                               # append model's function call message
 "role": "assistant",
 "content": None,
 "tool_calls": [tool_call]
})

messages.append({                               # append result message
 "role": "tool",                           
 "tool_call_id": tool_call.id,
 "content": json.dumps(result)
})

completion_2 = client.chat.completions.create(
    model=MODEL,
    messages=messages,
 
)
print(completion_2.choices[0].message.content)
```

</TabItem>
</Tabs>

## Tool-Aufrufe streamen

Setzen Sie `stream: true`, um Tool-Aufrufe während der Generierung zu erhalten. Die Argumente treffen im Feld `tool_calls` des Deltas ein. In `delta.content` erscheint kein Reasoning-Gerüst.

<Aside type="caution">
  **Ignorieren Sie Delta-Felder, die Sie nicht kennen.** Die Menge der Schlüssel in `delta` ist über die Modelle hinweg nicht festgelegt.

  `gpt-oss-120b` fügt dem Delta ein Feld `channel` hinzu, jedoch nur bei Streams **ohne** Tools. Es enthält den Wert `analysis`, während das Modell denkt. Sobald Sie ein `tools`-Array übergeben, fehlt das Feld. Kein anderes Modell sendet es.

  | Anfrage | Delta-Schlüssel |
  | :------ | :-------------- |
  | `gpt-oss-120b`, ohne Tools | `channel`, `content`, `reasoning`, `role` |
  | `gpt-oss-120b`, mit Tools | `content`, `reasoning`, `role`, `tool_calls` |
  | Jedes andere Modell | `content`, `reasoning`, `role`, `tool_calls` |

  Ein Client, der Delta-Schlüssel strikt validiert, bricht im ersten Fall ab. Lesen Sie die Felder, die Sie benötigen, und verwerfen Sie den Rest.
</Aside>

## JSON-Schema

Sie können den Parameter `response_format` auf Ihr definiertes Schema setzen, um sicherzustellen, dass das Modell ein JSON-Objekt erzeugt, das Ihrer angegebenen Struktur entspricht.

<Tabs syncKey="code">
<TabItem label="Python (SambaNova)">

```python
import sambanova
import json

# Define the SambaNova client
client = sambanova.SambaNova(
    base_url="https://api.infercom.ai/v1",
    api_key="ihr-infercom-api-schluessel"
)

MODEL = "DeepSeek-V3.1"

# Define the schema
response_format = {
    "type": "json_schema",
    "json_schema": {
        "name": "data_extraction",
        "schema": {
            "type": "object",
            "properties": {
                "section": {
                    "type": "string"
                },
                "products": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                }
            },
            "required": ["section", "products"],
            "additionalProperties": False
        },
        "strict": False 
    }
}

# Call the API
completion = client.chat.completions.create(
    model=MODEL,
    messages=[
        {
            "role": "system",
            "content": "You are an expert at structured data extraction. You will be given unstructured text and should convert it into the given structure."
        },
        {
            "role": "user",
            "content": "the section 24 has appliances, and videogames"
        }
    ],
    response_format=response_format
)

# Print the parsed result
print(completion)
```

</TabItem>
<TabItem label="Python (OpenAI)">

```python
import openai
import json

# Define the OpenAI client
client = openai.OpenAI(
    base_url="https://api.infercom.ai/v1",
    api_key="ihr-infercom-api-schluessel"
)

MODEL = "DeepSeek-V3.1"

# Define the schema
response_format = {
    "type": "json_schema",
    "json_schema": {
        "name": "data_extraction",
        "schema": {
            "type": "object",
            "properties": {
                "section": {
                    "type": "string"
                },
                "products": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                }
            },
            "required": ["section", "products"],
            "additionalProperties": False
        },
        "strict": False 
    }
}

# Call the API
completion = client.chat.completions.create(
    model=MODEL,
    messages=[
        {
            "role": "system",
            "content": "You are an expert at structured data extraction. You will be given unstructured text and should convert it into the given structure."
        },
        {
            "role": "user",
            "content": "the section 24 has appliances, and videogames"
        }
    ],
    response_format=response_format
)

# Print the parsed result
print(completion)
```

</TabItem>
</Tabs>

<Aside type="note">
  Stellen Sie sicher, dass Sie den Parameter `"strict"` auf `false` setzen, da `true` noch nicht unterstützt wird. Wenn es verfügbar ist, wird es sicherstellen, dass das Modell Ihr Funktionsschema strikt befolgt, anstatt einen Best-Effort-Versuch zu unternehmen.
</Aside>

## JSON-Modus

Sie können den Parameter `response_format` in Ihrer Anfrage auf `json_object` setzen, um sicherzustellen, dass das Modell ein gültiges JSON ausgibt. Falls der Modus kein gültiges JSON generieren kann, wird ein Fehler zurückgegeben.

<Aside type="note">
  Falls das Modell kein gültiges JSON generieren kann, erhalten Sie eine Fehlermeldung **Model did not output valid JSON**.
</Aside>

<Tabs syncKey="code">
<TabItem label="Python (SambaNova)">

```json
import sambanova

# Define the SambaNova client
client = sambanova.SambaNova(
    base_url="https://api.infercom.ai/v1",
    api_key="ihr-infercom-api-schluessel"
)

MODEL = 'gpt-oss-120b'


def run_conversation(user_prompt):
    # Initial conversation with user input
    messages = [
        {
            "role": "system",
            "content": "Always provide the response in this JSON format: {\"country\": \"name\", \"capital\": \"xx\"}"
        },

        {
            "role": "user",
            "content": user_prompt,
        }
    ]

    # First API call to get model's response
    response = client.chat.completions.create(
        model=MODEL,
        messages=messages,
        max_tokens=500,
        response_format = { "type": "json_object"},
        # stream = True
    )
    
    response_message = response.choices[0].message
    print(response_message)


run_conversation('what is the capital of Austria')
```

</TabItem>
<TabItem label="Python (OpenAI)">

```json
import openai

# Define the OpenAI client
client = openai.OpenAI(
    base_url="https://api.infercom.ai/v1",
    api_key="ihr-infercom-api-schluessel"
)

MODEL = 'gpt-oss-120b'


def run_conversation(user_prompt):
    # Initial conversation with user input
    messages = [
        {
            "role": "system",
            "content": "Always provide the response in this JSON format: {\"country\": \"name\", \"capital\": \"xx\"}"
        },

        {
            "role": "user",
            "content": user_prompt,
        }
    ]

    # First API call to get model's response
    response = client.chat.completions.create(
        model=MODEL,
        messages=messages,
        max_tokens=500,
        response_format = { "type": "json_object"},
        # stream = True
    )
    
    response_message = response.choices[0].message
    print(response_message)


run_conversation('what is the capital of Austria')
```

</TabItem>
</Tabs>

```json title="Example response"
ChatCompletionMessage(content='{"country": "Austria", "capital": "Vienna"}', role='assistant', function_call=None, tool_calls=None)
```

### Andere Methoden für strukturierte Ausgaben

Neben dem JSON-Modus können strukturierte Ausgaben auch mithilfe der [Instructor-Bibliothek](https://python.useinstructor.com/) generiert werden, die einen praktischen Wrapper zum Extrahieren strukturierter Daten aus LLM-Antworten mittels Pydantic-Modellen bietet.