

# Ziele für Inferenzkonnektoren
<a name="gateway-target-inference-connector"></a>

Ziele für Inferenzkonnektoren bieten eine vorkonfigurierte Konfiguration für unterstützte Modellanbieter. Wenn Sie einen Konnektor verwenden, verarbeitet das Gateway automatisch Operationen, die Modellerkennung, die Modell-ID-Übersetzung und das Umschreiben von Pfaden auf der Grundlage der integrierten Kenntnisse der API des Anbieters, sodass Sie sie nicht manuell angeben müssen.

Konnektoren werden empfohlen, wenn Sie schnell einen unterstützten Modellanbieter hinzufügen möchten, ohne Endpunkte, Operationen oder Modellzuordnungen manuell konfigurieren zu müssen.

**Topics**
+ [Zielkonfiguration](#gateway-target-inference-connector-config)
+ [Ein Konnektor-Inferenzziel erstellen](#gateway-target-inference-connector-create)
+ [Aufrufen eines Konnektor-Inferenzziels](#gateway-target-inference-connector-invoke)
+ [Verfügbare Modelle auflisten](#gateway-target-inference-connector-list-models)
+ [Model-based Routing](#gateway-target-inference-connector-routing)
+ [Streaming](#gateway-target-inference-connector-streaming)
+ [Ausgehende Autorisierung](#gateway-target-inference-connector-auth)

## Zielkonfiguration
<a name="gateway-target-inference-connector-config"></a>

Die Zielkonfiguration für ein Ziel eines Inferenzkonnektors verwendet die folgende Struktur:

```
{
    "inference": {
        "connector": {
            "source": {
                "connectorId": "bedrock-mantle"
            }
        }
    }
}
```
+  **connectorId** (erforderlich) — Bezeichner für den integrierten Connector. Unterstützte Werte sind `bedrock-mantle`, `openai` und `anthropic`.

Jeder Connector bietet integrierte Standardeinstellungen, die einer vollständig spezifizierten Anbieterkonfiguration entsprechen. Der `bedrock-mantle` Connector konfiguriert beispielsweise automatisch:
+  Entfernung des **Model-ID-Präfixes** — Kunden können das Anbieterpräfix in Modell-IDs weglassen (z. B. `claude-opus-4-7` anstelle von verwenden). `anthropic.claude-opus-4-7`
+  **Umschreiben von Pfaden** — Die Pfade für eingehende Inferenzanfragen werden den API-Pfaden des Anbieters zugeordnet.
+  **Unterstützte Operationen** — Die Gruppe von Inferenzoperationen, die der Konnektor verfügbar macht, z. B. Chat-Abschlüsse und Nachrichten.

## Ein Konnektor-Inferenzziel erstellen
<a name="gateway-target-inference-connector-create"></a>

Das folgende Beispiel zeigt, wie ein Inferenzziel mithilfe des Bedrock Mantle-Konnektors erstellt wird:

```
aws bedrock-agentcore-control create-gateway-target --cli-input-json '{
    "gatewayIdentifier": "GATEWAY_ID",
    "name": "bedrock-mantle",
    "targetConfiguration": {
        "inference": {
            "connector": {
                "source": {
                    "connectorId": "bedrock-mantle"
                }
            }
        }
    },
    "credentialProviderConfigurations": [
        {"credentialProviderType": "GATEWAY_IAM_ROLE"}
    ]
}'
```

Das folgende Beispiel zeigt, wie Sie mit dem OpenAI-Konnektor ein Inferenzziel erstellen:

```
aws bedrock-agentcore-control create-gateway-target --cli-input-json '{
    "gatewayIdentifier": "GATEWAY_ID",
    "name": "openai",
    "targetConfiguration": {
        "inference": {
            "connector": {
                "source": {
                    "connectorId": "openai"
                }
            }
        }
    },
    "credentialProviderConfigurations": [
        {
            "credentialProviderType": "API_KEY",
            "credentialProvider": {
                "apiKeyCredentialProvider": {
                    "providerArn": "arn:aws:bedrock-agentcore:us-west-2:111122223333:token-vault/default/apikeycredentialprovider/openai-key",
                    "credentialLocation": "HEADER",
                    "credentialParameterName": "Authorization",
                    "credentialPrefix": "Bearer "
                }
            }
        }
    ]
}'
```

Das folgende Beispiel zeigt, wie ein Inferenzziel mithilfe des Anthropic-Konnektors erstellt wird:

```
aws bedrock-agentcore-control create-gateway-target --cli-input-json '{
    "gatewayIdentifier": "GATEWAY_ID",
    "name": "anthropic",
    "targetConfiguration": {
        "inference": {
            "connector": {
                "source": {
                    "connectorId": "anthropic"
                }
            }
        }
    },
    "credentialProviderConfigurations": [
        {
            "credentialProviderType": "API_KEY",
            "credentialProvider": {
                "apiKeyCredentialProvider": {
                    "providerArn": "arn:aws:bedrock-agentcore:us-west-2:111122223333:token-vault/default/apikeycredentialprovider/anthropic-key",
                    "credentialLocation": "HEADER",
                    "credentialParameterName": "x-api-key"
                }
            }
        }
    ]
}'
```

## Aufrufen eines Konnektor-Inferenzziels
<a name="gateway-target-inference-connector-invoke"></a>

Um ein Inferenzziel aufzurufen, senden Sie Anfragen an den Pfad des Gateways. `/inference` Das Gateway leitet jede Anfrage basierend auf dem `model` Feld im Anfragetext an das richtige Ziel weiter. Der `model` Wert kann entweder eine einfache Modell-ID (z. B.`gpt-5.5`) oder eine zielqualifizierte Modell-ID in der Form `{targetName}/{modelId}` (z. B.`openai/gpt-5.5`) sein. [Einzelheiten dazu, wie der `model` Wert einem Ziel zugeordnet wird, finden Sie unter Model-based Routing.](#gateway-target-inference-connector-routing)

Das URL-Format ist:

```
https://{gatewayId}.gateway.bedrock-agentcore.{region}.amazonaws.com/inference/{path}
```

`{path}`Ersetzen Sie es durch den Pfad der Inferenzoperation (z. B.`v1/chat/completions`,`v1/responses`, oder`v1/messages`).

### Verwenden des OpenAI SDK
<a name="_using_the_openai_sdk"></a>

Stellen Sie den `/inference/v1` Pfad des Gateways wie folgt ein: `base_url`

```
from openai import OpenAI

client = OpenAI(
    base_url="https://<gateway-id>.gateway.bedrock-agentcore.us-west-2.amazonaws.com/inference/v1",
    api_key="<gateway-auth-token>"
)

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "Hello!"}]
)
```

### Verwenden des Anthropic SDK
<a name="_using_the_anthropic_sdk"></a>

Stellen Sie den `/inference` Pfad des Gateways wie folgt ein: `base_url`

```
import anthropic

client = anthropic.Anthropic(
    base_url="https://<gateway-id>.gateway.bedrock-agentcore.us-west-2.amazonaws.com/inference",
    api_key="<gateway-auth-token>"
)

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}]
)
```

### Verwenden von awscurl
<a name="_using_awscurl"></a>

```
awscurl --service bedrock-agentcore --region us-west-2 -X POST \
    "https://<gateway-id>.gateway.bedrock-agentcore.us-west-2.amazonaws.com/inference/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -d '{"model": "gpt-5.5", "messages": [{"role": "user", "content": "Hello!"}]}'
```

## Verfügbare Modelle auflisten
<a name="gateway-target-inference-connector-list-models"></a>

Rufen Sie den Endpunkt „Modelle auflisten“ auf, um Modelle zu ermitteln, die für alle Inferenzziele verfügbar sind:

```
awscurl --service bedrock-agentcore --region us-west-2 \
    "https://<gateway-id>.gateway.bedrock-agentcore.us-west-2.amazonaws.com/inference/v1/models"
```

Die Antwort ist im `/v1/models` OpenAI-Format mit Modell-IDs, denen der Zielname vorangestellt ist:

```
{
    "data": [
        {"id": "bedrock-mantle/anthropic.claude-opus-4-7", "object": "model", "owned_by": "system"},
        {"id": "openai/gpt-5.5", "object": "model", "owned_by": "openai"},
        {"id": "anthropic/claude-sonnet-4-6", "object": "model", "owned_by": "anthropic"}
    ]
}
```

Das `owned_by` Feld gibt den Anbieter des Modells an. Ein Wert von `system` steht für ein Modell, das von Amazon Bedrock gehostet wird, `openai` und ein Wert von steht für `anthropic` Modelle, die direkt von diesen Anbietern bereitgestellt werden.

## Model-based Routing
<a name="gateway-target-inference-connector-routing"></a>

Das Gateway leitet Inferenzanfragen auf der Grundlage des `model` Felds im Hauptteil der Anfrage weiter:

1.  **Qualifiziertes Routing** — Wenn die Modell-ID ein enthält `/` und das Präfix mit einem Zielnamen übereinstimmt, wird die Anfrage an dieses Ziel weitergeleitet (z. B. `openai/gpt-5.5` Routen zum `openai` Ziel).

1.  **Unqualifiziertes Routing** — Wenn die Modell-ID kein A enthält`/`, gleicht das Gateway es mit allen konfigurierten Zielen ab. Eine exakte Übereinstimmung hat Vorrang vor Glob-Mustern. Wenn genau ein Ziel übereinstimmt, wird die Anfrage an dieses Ziel weitergeleitet.

1.  **Kollisionsbehandlung** — Wenn mehrere Ziele demselben Modell mit derselben Spezifität entsprechen, verwendet das Gateway standardmäßig das Amazon Bedrock-Ziel, wenn eines der Treffer enthalten ist. Andernfalls wählt es bei jeder Anfrage nach dem Zufallsprinzip eines der passenden Ziele aus, sodass Anfragen für dasselbe Modell auf unterschiedlichen Zielen landen können. Um Anfragen an ein bestimmtes Ziel zu binden, qualifizieren Sie das Modell mit dem Zielnamen als Präfix (z. B.`bedrock/claude-opus-4-7`).

## Streaming
<a name="gateway-target-inference-connector-streaming"></a>

Streaming folgt der OpenAI SSE-Konvention. Wird `"stream": true` im Anforderungstext festgelegt, und das Gateway durchläuft den SSE-Stream vom Anbieter ohne Transformation:

```
stream = client.chat.completions.create(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "Write a story."}],
    stream=True
)

for chunk in stream:
    print(chunk.choices[0].delta.content, end="")
```

### Grenzwerte für den Antwortstream
<a name="gateway-target-inference-connector-streaming-limits"></a>

**Wichtig**  
AgentCore Gateway erzwingt kein Service-Level-Maximum für die Dauer oder Größe des Antwortstreams. Wenn Sie für Ihr Gateway-Ziel keine Token-Limit-Richtlinie konfigurieren, kann jede Anfrage eine unbegrenzte Streaming-Antwort generieren.

Ohne eine konfigurierte Token-Limit-Richtlinie können unbegrenzte Antworten die folgenden Probleme verursachen:
+  **Erschöpfung der Gateway-Ressourcen** — Das Gateway hält Rechenressourcen (Speicher, HTTP-Verbindungspool-Steckplätze und CPU für die Richtlinienauswertung) für die Dauer jeder Streaming-Antwort offen. Große gleichzeitige Streams können die Ressourcen der Gateway-Aufgaben erschöpfen.
+  **Kostensteigerung bei gemeinsam genutzten Anmeldeinformationen** — Alle Benutzer, die über dasselbe Ziel weiterleiten, teilen sich dieselben Anbieteranmeldedaten. Ein einzelner Benutzer, der hohe `max_tokens` Anfragen sendet, kann das TPM-Kontingent (Tokens per Minute) des Anbieters für alle Benutzer dieses Ziels verbrauchen.
+  **Nebengeräuscheffekte** — Drosselung Requests-per-minute (RPM) begrenzt die Anzahl der Anfragen, nicht aber die Kosten pro Anfrage. Ein einzelner Benutzer kann innerhalb des RPM-Limits Anfragen mit den höchsten Kosten generieren, wodurch die Leistung anderer Benutzer beeinträchtigt wird.

Um diese Risiken zu minimieren, konfigurieren Sie eine Token-Limit-Richtlinie für Ihre Gateway-Ziele. Weitere Informationen finden Sie unter [Gateway-Richtlinien](gateway-policies.html).

## Ausgehende Autorisierung
<a name="gateway-target-inference-connector-auth"></a>

Inference Connector-Ziele unterstützen die folgenden Autorisierungstypen für ausgehenden Datenverkehr:
+  **IAM (SigV4)** — Wird `GATEWAY_IAM_ROLE` für Anbieter verwendet, die IAM-Authentifizierung akzeptieren (z. B. Amazon Bedrock).
+  **API-Schlüssel** — Wird `API_KEY` für Anbieter verwendet, die einen API-Schlüssel benötigen (wie OpenAI und Anthropic). Das Gateway fügt den gespeicherten API-Schlüssel in ausgehende Anfragen ein.