Documentation 2026-07-28 23:57 UTC to 2026-07-29 19:02 UTC

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

4 

5# Claude-Apps-Gateway für Amazon Bedrock, Claude Platform auf AWS, Google Cloud und Microsoft Foundry

6 

7> Führen Sie Claude Code über Amazon Bedrock, Claude Platform auf AWS, Google Cloud oder Microsoft Foundry hinter einem selbstgehosteten Gateway mit SSO-Anmeldung, Modellzugriff pro Gruppe und OTLP-Telemetrie aus.

8 

9<Note>

10 Das Claude-Apps-Gateway ist für Organisationen konzipiert, die Inferenzen über ihren eigenen Cloud-Anbieter leiten müssen oder möchten – beispielsweise um [Anforderungen zur Datenresidenz](/docs/de/claude-apps-gateway-deploy#compliance-posture) zu erfüllen. Wenn Sie diese Anforderung nicht haben und Zugriff auf andere Funktionen wie SCIM-Bereitstellung oder Claude Code im Web und auf Mobilgeräten wünschen, ist Claude Enterprise möglicherweise besser geeignet. Weitere Informationen finden Sie auf der Seite zur [Funktionsverfügbarkeit](/docs/de/feature-availability), um einen vollständigen Vergleich aller Bereitstellungsmethoden zu erhalten.

11</Note>

12 

13Claude-Apps-Gateway ist ein selbstgehosteter Service, der sich zwischen den Claude-Code-Clients Ihrer Entwickler und Ihrem Modellanbietern befindet. Entwickler melden sich mit Ihrem Unternehmensidentitätsanbieter (IdP) an, anstatt API-Schlüssel oder Cloud-Anmeldedaten zu halten. Das Gateway hält die Upstream-Anmeldedaten, erzwingt Modellzugriff und [verwaltete Einstellungen](/docs/de/permissions#managed-settings) nach IdP-Gruppe und leitet Nutzungstelemetrie an Ihren eigenen Observability-Stack weiter.

14 

15Es ist in der `claude`-Binärdatei enthalten, daher führt die gleiche ausführbare Datei, die Claude Code auf einem Laptop ausführt, den Gateway-Server mit `claude gateway --config gateway.yaml` aus.

16 

17Diese Seite behandelt:

18 

19* [Warum Claude-Apps-Gateway](#why-claude-apps-gateway), was es gegenüber dem Betrieb Ihres eigenen hinzufügt, und wann etwas anderes besser passt

20* Ein [Schnellstart](#quickstart) mit [Voraussetzungen](#prerequisites), der ein Gateway von Null zu einem angemeldeten Entwickler bringt

21* [Entwickler verbinden](#connect-developers), einschließlich der Einstellung der Gateway-URL durch verwaltete Einstellungen

22* [Verfügbarkeit und Einschränkungen](#availability-and-limitations), die abdecken, welche Claude-Code-Funktionen über das Gateway funktionieren und was der Server unterstützt

23 

24Begleitseiten gehen tiefer. Die [Konfigurationsreferenz](/docs/de/claude-apps-gateway-config) behandelt jede Option in der YAML-Datei, die der Schnellstart schreibt, und der [Bereitstellungsleitfaden](/docs/de/claude-apps-gateway-deploy) behandelt IdP-spezifische Einrichtung, Kubernetes- und Cloud-Run-Bereitstellung sowie Operationen.

25 

26<h2 id="why-claude-apps-gateway">

27 Warum Claude apps gateway

28</h2>

29 

30Die [Gateway-Übersicht](/docs/de/gateways) behandelt, was ein Gateway tut und warum Sie eines ausführen würden. Claude apps gateway ist Anthropics eigenes Gateway, das in die `claude`-Binärdatei integriert und neben jeder Claude-Code-Version getestet wird, daher leitet es die Header und Anforderungsfelder weiter, die Claude Code sendet, ohne dass Operatoren eine separate Zulassungsliste verwalten müssen. Nach der Bereitstellung erhalten Sie:

31 

32* **Anmeldedaten**: Der Upstream-API-Schlüssel oder die Cloud-Anmeldedaten befinden sich nur in Ihrer Infrastruktur. Entwickler authentifizieren sich mit Corporate SSO und erhalten kurzlebige Bearer-Token, daher erfolgt das Offboarding in Ihrem IdP. Heben Sie die Bereitstellung eines Benutzers auf und sein Gateway-Zugriff läuft innerhalb der Sitzungsdauer ab, standardmäßig eine Stunde.

33* **Zugriffskontrolle**: Ihre IdP-Gruppen werden Modellzulassungslisten und [verwaltete Einstellungen](/docs/de/permissions#managed-settings)-Richtlinien zugeordnet. Das Gateway erzwingt Modellzugriff auf der Serverseite, lehnt Anfragen für nicht gewährte Modelle ab und wählt die verwaltete Einstellungsrichtlinie jeder Gruppe aus, die die CLI auf der [Ebene der verwalteten Einstellungen](/docs/de/settings#settings-precedence) anwendet. Verschiedene Teams erhalten verschiedene Modelle, Tools und Berechtigungen, und ein Entwickler kann nicht überschreiben, was seine Richtlinie sperrt.

34* **Einstellungsbereitstellung**: Das Gateway liefert verwaltete Einstellungen selbst an angemeldete Clients und ersetzt [servergesteuerte Einstellungen](/docs/de/server-managed-settings) aus der claude.ai-Admin-Konsole.

35* **Telemetrie**: Jedes konfigurierte Ziel, wie Datadog, Splunk oder ClickHouse, empfängt [OpenTelemetry-Protokoll (OTLP)-Metriken](/docs/de/monitoring-usage) mit Token-Zählungen, Modell, Benutzeridentität und Latenz standardmäßig, mit Protokollen und Traces als optionale Ziele.

36* **Upstream-Routing**: Clients sprechen die Anthropic Messages API mit dem Gateway, und das Gateway übersetzt für jeden Upstream, ob Amazon Bedrock, [Claude Platform on AWS](/docs/de/claude-platform-on-aws), Google Clouds Agent Platform, Microsoft Foundry oder die Anthropic API, mit Failover zwischen ihnen. Sie können Regionen, Anbieter oder Failover-Reihenfolge ändern, ohne dass Entwickler dies bemerken oder neu konfigurieren müssen.

37 

38<Frame>

39 <img src="https://mintcdn.com/claude-code/st9_ZQOFsZa3cKFl/images/claude-gateway-architecture.svg?fit=max&auto=format&n=st9_ZQOFsZa3cKFl&q=85&s=560770d8f49bbd6f1ca7090ed1f13c03" alt="Diagramm, das Claude-Code-Clients zeigt, die sich über HTTPS mit Bearer-Token mit einem selbstgehosteten Claude-Apps-Gateway in Ihrer Infrastruktur verbinden, das Benutzer gegen Ihren IdP authentifiziert, Auth-Status in PostgreSQL speichert, Telemetrie an Ihren OTLP-Collector weiterleitet und Inferenzen an Amazon Bedrock, Claude Platform on AWS, Google Cloud, Microsoft Foundry oder die Anthropic API weiterleitet" width="760" height="320" data-path="images/claude-gateway-architecture.svg" />

40</Frame>

41 

42<Note>

43 Die Datenebene des Gateways selbst sendet nichts an die Anthropic-Infrastruktur, es sei denn, die Anthropic API ist ein konfigurierter Upstream. Sie kontrollieren, wohin Telemetrie, Audit-Protokolle, verwaltete Einstellungen und die IdP-Identität Ihrer Entwickler gehen, und das Gateway sendet keine davon an Anthropic. Für den verbleibenden Datenverkehr, den der CLI-Prozess senden kann, und wie man ihn schließt, siehe [Compliance-Postur](/docs/de/claude-apps-gateway-deploy#compliance-posture).

44</Note>

45 

46Welche Claude-Code-Funktionen über das Gateway funktionieren und was der Server selbst unterstützt, siehe [Verfügbarkeit und Einschränkungen](#availability-and-limitations) unten. Für Entscheidungen wie Kosten, Umgehung, Ausführung mehrerer Gateways und serverlose Plattformen siehe den [Bereitstellungsleitfaden](/docs/de/claude-apps-gateway-deploy#deployment).

47 

48<h3 id="other-gateway-implementations">

49 Andere Gateway-Implementierungen

50</h3>

51 

52Wenn Sie bereits ein LLM-Gateway oder API-Gateway ausführen, das Ihre Anforderungen erfüllt, verwenden Sie es weiterhin; [Andere LLM-Gateways](/docs/de/llm-gateway) behandelt die Konfiguration von Claude Code dagegen.

53 

54Die [Gateway-Protokollreferenz](/docs/de/llm-gateway-protocol) dokumentiert den Vertrag, den Claude Code von jedem Gateway erwartet: die Endpunkte, die es aufruft, die Header und Body-Felder zum Weiterleiten und was nicht funktioniert, wenn sie entfernt werden. Ein laufendes Claude-Apps-Gateway bedient eine Obermenge dieses Vertrags unter `GET /protocol`, wobei die Claude-Apps-Gateway-spezifischen Endpunkte für SSO-Anmeldung, Verwaltete-Einstellungen-Bereitstellung und Telemetrie hinzugefügt werden. Rufen Sie es mit `curl https://claude-gateway.internal.example.com/protocol` von jedem bereitgestellten Gateway ab, wie dem, das der [Schnellstart](#quickstart) unten erzeugt.

55 

56Breaking Changes am Protokoll werden im Voraus angekündigt, aber unbegrenzte Rückwärtskompatibilität ist nicht garantiert.

57 

58<h2 id="quickstart">

59 Schnellstart

60</h2>

61 

62Dieser Schnellstart führt den minimalen Weg: Registrieren Sie einen OAuth-Client in Ihrem IdP, schreiben Sie eine `gateway.yaml`, führen Sie das Gateway zusammen mit Postgres mit Docker Compose aus und überprüfen Sie die Anmeldung von Ende zu Ende. Es verwendet einen Amazon-Bedrock-Upstream; Claude Platform auf AWS, Google Clouds Agent Platform, Microsoft Foundry und die Anthropic API werden gleichermaßen unterstützt, indem Sie den `upstreams`-Block wie in der [Konfigurationsreferenz](/docs/de/claude-apps-gateway-config#upstreams) gezeigt austauschen. Am Ende haben Sie ein Gateway, bei dem sich ein Entwickler `/login` anmelden kann.

63 

64<Note>

65 **Bereitstellung in Ihrem privaten Netzwerk.** Claude Code verbindet sich nur mit einem Gateway, dessen Adresse privat ist. Dies ist eine Sicherheitsmaßnahme, da ein vertrauenswürdiges Gateway Einstellungen pushen kann, die Befehle auf Entwicklermaschinen ausführen. Platzieren Sie das Gateway hinter einem internen Load Balancer oder VPN und geben Sie ihm einen Hostnamen, der nur zu privaten IPs aufgelöst wird.

66 

67 Anthropic-betriebene öffentliche Gateway-Endpunkte sind die Ausnahme: `/login` akzeptiert sie über `https://`. Dies ist eine kleine feste Menge von Gateways, die Anthropic selbst betreibt; sie sind keine Bereitstellungsoption, die Sie auswählen oder konfigurieren können. Die Liste ist in Claude Code kompiliert, daher kann keine Konfiguration einen Hostnamen hinzufügen und kein von Ihnen gehostetes Gateway qualifiziert sich für die Ausnahme. {/* min-version: 2.1.206 */}Vor v2.1.206 lehnte `/login` diese Endpunkte wie jede andere öffentliche Adresse ab.

68</Note>

69 

70<h3 id="prerequisites">

71 Voraussetzungen

72</h3>

73 

74Haben Sie diese vor dem Start bereit:

75 

76| Sie benötigen | Details |

77| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

78| Claude Code v2.1.195 oder später | Der `claude gateway`-Unterbefehl und der Gateway-Anmeldungsfluss werden in v2.1.195 ausgeliefert. Frühere öffentliche Builds enthalten sie nicht. Sowohl die Maschine, auf der der Gateway-Server läuft, als auch die Maschine jedes Entwicklers müssen v2.1.195 oder später sein; führen Sie `claude update` aus, um die neueste Version zu erhalten. {/* min-version: 2.1.198 */}Die [Claude Platform auf AWS Upstream](/docs/de/claude-apps-gateway-config#claude-platform-on-aws) erfordert Claude Code v2.1.198 oder später auf dem Gateway-Server. |

79| OpenID Connect (OIDC)-Identitätsanbieter | Okta, Microsoft Entra ID, Google Workspace, Keycloak oder Dex, oder ein anderer OIDC-konformer IdP wie PingFederate. Das Gateway führt Standard-OIDC-Erkennung und den Authorization-Code-Flow dagegen aus. SAML und LDAP werden nicht unterstützt. |

80| PostgreSQL 14 oder später | Unterstützt den Geräte-Anmeldungsfluss, bei dem der Browser-Callback schreibt und die Polling-CLI liest, sowie Rate-Limit-Zähler. Jedes verwaltete Postgres funktioniert, einschließlich der kleinsten Stufe. Ohne konfigurierte Ausgabenlimits speichert das Gateway einige KB kurzlebigen Auth-Status; mit [Ausgabenlimits](/docs/de/claude-apps-gateway-spend-limits) enthält es auch dauerhafte Ausgaben-, Audit- und Identitätstabellen, die gesichert werden sollten. TLS über `?sslmode=require` wird empfohlen. |

81| Modell-Upstream | Amazon-Bedrock-Anmeldedaten, Claude Platform auf AWS Anmeldedaten, Google-Cloud-Anmeldedaten, eine Microsoft-Foundry-Ressource oder einen Anthropic-API-Schlüssel. Mehrere Upstreams werden mit Failover unterstützt. |

82| HTTPS | Das Gateway muss über `https://` von Entwickler-Laptops und von jedem Browser, der für die Anmeldung verwendet wird, erreichbar sein; das Gateway bedient die Geräteüberprüfungsseite auf dem gleichen Listener. Stellen Sie entweder ein TLS-Zertifikat über `listen.tls` bereit, oder führen Sie hinter einem TLS-terminierenden Ingress aus und setzen Sie `listen.public_url`. Ein einfacher `http://`-Ursprung wird nur auf Loopback für lokale Entwicklung akzeptiert. |

83| Private-Netzwerk-Adresse | Bei `/login` erfordert Claude Code, dass der Hostname oder die IP-Adresse des Gateways nur zu privaten Adressen aufgelöst wird: RFC 1918, CGNAT `100.64.0.0/10`, IPv6 ULA `fc00::/7` oder Loopback für lokale Entwicklung. Die Überprüfung wird auf jeder aufgelösten IP ausgeführt, daher lehnt `/login` die URL ab, wenn eine Adresse, zu der der Name aufgelöst wird, öffentlich ist. Wenn Entwicklermaschinen HTTPS über einen Unternehmens-Proxy leiten, erfordert die Anmeldung auch, dass der Proxy-Host zu privaten Adressen aufgelöst wird; wenn nicht, fügen Sie den Gateway-Host zu `NO_PROXY` hinzu, damit die CLI direkt verbunden wird. {/* min-version: 2.1.206 */}Anthropic-betriebene öffentliche Gateway-Endpunkte sind von den Überprüfungen für private Adressen und Proxys ausgenommen: `/login` akzeptiert sie über `https://` durch exakte Hostname-Übereinstimmung, daher gilt die Private-Netzwerk-Anforderung nur für ein von Ihnen selbst gehostetes Gateway. Vor v2.1.206 lehnte `/login` einen Anthropic-betriebenen Endpunkt wie jede andere öffentliche Adresse ab. |

84| Linux-Laufzeit | Der Gateway-Server läuft nur auf der nativen Linux-Binärdatei. macOS funktioniert für lokale Entwicklung. Windows wird nicht als Serverplattform unterstützt. |

85 

86Der Gateway-Server erfordert die native `claude`-Binärdatei; laden Sie eine angeheftete Version wie in [Claude Code installieren](/docs/de/setup) beschrieben herunter. Der Server verwendet Laufzeitfunktionen, die nicht verfügbar sind, wenn Claude Code unter Node ausgeführt wird. Wenn Sie `requires the native binary` beim Start sehen, wechseln Sie zu einer der eigenständigen Installationsmethoden.

87 

88<h3 id="steps">

89 Schritte

90</h3>

91 

92<Steps>

93 <Step title="Registrieren Sie einen OAuth-Client in Ihrem IdP">

94 Entscheiden Sie zuerst den Hostnamen des Gateways, da der Redirect-URI damit übereinstimmen muss. Erstellen Sie eine neue OIDC-Webanwendung und setzen Sie den Redirect-URI auf `https://claude-gateway.<your-domain>/oauth/callback`, wobei der Host der gleiche Wert ist, den Sie als [`listen.public_url`](/docs/de/claude-apps-gateway-config#listen) in Schritt 3 setzen. Notieren Sie sich die `client_id` und `client_secret`. IdP-spezifische Anweisungen finden Sie unter [Identitätsanbieter-Einrichtung](/docs/de/claude-apps-gateway-deploy#identity-provider-setup).

95 </Step>

96 

97 <Step title="Stellen Sie eine PostgreSQL-Datenbank bereit">

98 Jedes Postgres 14 oder später funktioniert, einschließlich der kleinsten verwalteten Stufe. Das Gateway führt seine eigenen Schema-Migrationen beim Start aus, daher benötigt der Datenbankbenutzer `CREATE TABLE`-Berechtigung. Wenn Ihre Sicherheitsrichtlinie DDL von Anwendungsrollen verbietet, erstellen Sie das Schema stattdessen voraus; siehe [`store`](/docs/de/claude-apps-gateway-config#store).

99 </Step>

100 

101 <Step title="Schreiben Sie gateway.yaml">

102 Geheimnisse werden über `${ENV_VAR}`-Erweiterung gelesen, daher kann die Datei selbst in der Versionskontrolle leben. Verwenden Sie einen `public_url`-Hostnamen, der zu einer privaten IP in Ihrem Netzwerk aufgelöst wird, da `/login` öffentliche Adressen ablehnt. Die minimale Konfiguration hat fünf Abschnitte, und jedes andere Feld hat einen Standard:

103 

104 ```yaml gateway.yaml theme={null}

105 listen:

106 host: 0.0.0.0

107 port: 8080

108 # Erforderlich hinter jedem TLS-terminierenden Proxy. Wird für den IdP

109 # redirect_uri und das Discovery-Dokument verwendet.

110 public_url: https://claude-gateway.internal.example.com

111 

112 oidc:

113 issuer: https://login.example.com # muss /.well-known/openid-configuration bedienen

114 client_id: 0oa1example2

115 client_secret: ${OIDC_CLIENT_SECRET}

116 allowed_email_domains: [example.com] # lehne id_tokens außerhalb Ihrer Organisation ab

117 userinfo_fallback: true # für IdPs, deren id_token E-Mail/Gruppen auslässt; ansonsten harmlos

118 

119 session:

120 jwt_secret: ${GATEWAY_JWT_SECRET} # openssl rand -base64 32

121 ttl_hours: 1 # begrenzt auch die Widerrufungslatenz bei IdP-Entbereitstellung

122 

123 store:

124 postgres_url: ${GATEWAY_POSTGRES_URL} # fügen Sie ?sslmode=require für verwaltetes Postgres hinzu

125 

126 upstreams:

127 - provider: bedrock

128 region: us-east-1

129 auth: {} # leer: AWS-Standard-Anmeldekette

130 # (IRSA, EC2/ECS-Task-Rolle, Umgebungsvariablen, ~/.aws)

131 

132 # Modelle werden pro Upstream automatisch übersetzt. Der integrierte Katalog

133 # ordnet claude-opus-4-8 us.anthropic.claude-opus-4-8 zu und so weiter für jedes

134 # von Bedrock unterstützte Claude-Modell. Setzen Sie false und fügen Sie eine `models:`-Liste hinzu, um

135 # nur bestimmte Modelle verfügbar zu machen.

136 auto_include_builtin_models: true

137 ```

138 

139 Diese Konfiguration reicht für eine funktionierende Anmeldeschleife mit dem Standard-Bedrock-Modellkatalog aus. Sobald es läuft, fügen Sie Pro-Gruppen-RBAC und verwaltete Einstellungen über [`managed.policies`](/docs/de/claude-apps-gateway-config#managed) hinzu, Telemetrie-Verteilung über [`telemetry`](/docs/de/claude-apps-gateway-config#telemetry) und Multi-Upstream-Failover, bereitgestellte Durchsatz-ARNs oder Nicht-US-Regionen über [`models`](/docs/de/claude-apps-gateway-config#models).

140 

141 <Note>

142 Der Bedrock-Upstream benötigt einen AWS-Principal mit `bedrock:InvokeModel` und `bedrock:InvokeModelWithResponseStream` auf beiden `inference-profile/us.anthropic.*`-ARNs und den zugrunde liegenden `foundation-model/anthropic.*`-ARNs, und Modellzugriff muss in der Bedrock-Konsole für die Claude-Modelle aktiviert sein, die Sie möchten. Stellen Sie die Anmeldedaten mit IRSA auf EKS, einer ECS-Task-Rolle oder einem EC2-Instance-Profil bereit, anstatt statische Schlüssel zu verwenden. Die [`upstreams`-Referenz](/docs/de/claude-apps-gateway-config#upstreams) hat die vollständigen IAM-Details, die Cloud-übergreifende Anmeldedaten-Matrix und die `auth`-Blöcke für die anderen Anbieter.

143 </Note>

144 </Step>

145 

146 <Step title="Führen Sie es aus">

147 Erstellen Sie ein Container-Image um die `claude`-Binärdatei, die die [Image-Anforderungen](/docs/de/claude-apps-gateway-deploy#container-image) erfüllt, und führen Sie es zusammen mit Postgres aus:

148 

149 ```yaml docker-compose.yaml theme={null}

150 services:

151 gateway:

152 image: <your-registry>/claude-gateway:<version>

153 ports: ["8080:8080"]

154 volumes: ["./gateway.yaml:/etc/claude/gateway.yaml:ro"]

155 environment:

156 OIDC_CLIENT_SECRET: ${OIDC_CLIENT_SECRET}

157 GATEWAY_JWT_SECRET: ${GATEWAY_JWT_SECRET}

158 GATEWAY_POSTGRES_URL: postgres://gw:pw@postgres/gateway

159 # AWS-Anmeldedaten: in der Produktion diese auslassen und eine Instance-Rolle verwenden.

160 # Für lokales Compose-Testen, übergeben Sie Ihre eigenen:

161 AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID}

162 AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY}

163 AWS_SESSION_TOKEN: ${AWS_SESSION_TOKEN}

164 depends_on:

165 postgres:

166 condition: service_healthy

167 postgres:

168 image: postgres:16-alpine

169 environment: { POSTGRES_USER: gw, POSTGRES_PASSWORD: pw, POSTGRES_DB: gateway }

170 healthcheck:

171 test: ["CMD-SHELL", "pg_isready -U gw"]

172 interval: 5s

173 volumes: ["pgdata:/var/lib/postgresql/data"]

174 volumes: { pgdata: }

175 ```

176 

177 Das Gateway ist eine einzelne Linux-Binärdatei, die die Konfiguration liest, OIDC-Erkennung gegen Ihren IdP ausführt, ihre Postgres-Schema-Migrationen anwendet, Upstream-Clients erstellt und mit dem Abhören beginnt. Der Start ist fail-closed für die Konfiguration, die Postgres-Verbindung mit einem 5-Sekunden-Timeout, OIDC-Erkennung und Upstream-Client-Konstruktion. Wenn einer dieser Punkte unerreichbar oder falsch konfiguriert ist, beendet sich das Gateway mit einem Fehler, anstatt Datenverkehr in einem degradierten Zustand zu bedienen.

178 

179 Ein erfolgreicher Start validiert nicht den Inferenzpfad, da Bedrock- und Agent-Platform-Instance-Anmeldedaten bei der ersten Anfrage aufgelöst werden, nicht beim Start.

180 

181 Beobachten Sie stderr auf die Boot-Sequenz. Log-Zeilen verwenden das Format `[gateway] <timestamp> <level> <message>`, Audit-Events sind einzeilige JSON mit einem `evt`-Feld, und ein Startup-Banner, unten weggelassen, wird zwischen der Migration und den Listening-Zeilen gedruckt. Sie sollten in dieser Reihenfolge sehen:

182 

183 ```text theme={null}

184 {"ts":"2026-06-10T17:03:21.114Z","evt":"config.load","path":"/etc/claude/gateway.yaml","sha256":"…"}

185 [gateway] 2026-06-10T17:03:21.408Z info migration 1 applied

186 [gateway] 2026-06-10T17:03:21.512Z info claude gateway listening on http://0.0.0.0:8080

187 ```

188 

189 Wenn der Start vor der `claude gateway listening on`-Zeile beendet wird, benennt die letzte Zeile von stderr das Problem:

190 

191 * ein unerreichbares Postgres

192 * eine Postgres-Rolle ohne DDL-Berechtigung

193 * ein unerreichbares oder ungültiges OIDC-Discovery-Dokument

194 * eine Konfigurationsschema-Verletzung mit dem betroffenen Feldpfad

195 

196 Beheben Sie es und starten Sie neu.

197 

198 Wenn Sie bereits einen TLS-terminierenden Ingress haben, überspringen Sie Compose und führen Sie die Binärdatei direkt mit `claude gateway --config gateway.yaml` aus. Setzen Sie `public_url` auf den Ingress-Ursprung und binden Sie `listen` an eine Loopback- oder Cluster-interne Adresse.

199 </Step>

200 

201 <Step title="Überprüfen Sie die Auth-Oberfläche">

202 Drei Überprüfungen bestätigen, dass das Gateway einen echten Benutzer authentifizieren kann, bevor Sie es an einen Entwickler übergeben.

203 

204 Die Beispiele verwenden die öffentliche URL des Gateways; für das lokale Compose-Setup ohne Ingress ersetzen Sie `http://localhost:8080` in den ersten beiden Überprüfungen. Die dritte Überprüfung öffnet `verification_uri_complete`, das aus `public_url` erstellt wird, daher setzen Sie für lokales Compose `public_url: http://localhost:8080` in `gateway.yaml` und fügen Sie `http://localhost:8080/oauth/callback` als zweiten Redirect-URI auf dem OAuth-Client aus Schritt 1 hinzu, da das Gateway den IdP `redirect_uri` aus `public_url` erstellt. Der Überprüfungslink wird dann in Ihrem lokalen Browser geöffnet.

205 

206 Führen Sie in Windows PowerShell `curl.exe` aus; das bloße `curl` ist ein Alias für `Invoke-WebRequest` und lehnt diese Flags ab.

207 

208 Rufen Sie zunächst das Discovery-Dokument ab, das bestätigt, dass das Gateway aktiv ist, die Konfiguration gültig ist und alle Boot-Überprüfungen bestanden haben:

209 

210 ```bash theme={null}

211 curl -s https://claude-gateway.internal.example.com/.well-known/oauth-authorization-server | jq

212 ```

213 

214 ```json theme={null}

215 {

216 "issuer": "https://claude-gateway.internal.example.com",

217 "device_authorization_endpoint": "…/oauth/device_authorization",

218 "token_endpoint": "…/oauth/token",

219 "grant_types_supported": ["urn:ietf:params:oauth:grant-type:device_code", "refresh_token"]

220 }

221 ```

222 

223 Die Antwort enthält zusätzliche Felder wie `response_types_supported` und `scopes_supported`.

224 

225 Fordern Sie zweitens eine Geräteautorisierung an, die bestätigt, dass der Geräte-Anmeldungsfluss funktioniert und Postgres erreichbar und beschreibbar ist:

226 

227 ```bash theme={null}

228 curl -s -X POST https://claude-gateway.internal.example.com/oauth/device_authorization | jq

229 ```

230 

231 ```json theme={null}

232 {

233 "device_code": "…",

234 "user_code": "WDJB-MJHT",

235 "verification_uri": "https://claude-gateway.internal.example.com/device",

236 "verification_uri_complete": "https://claude-gateway.internal.example.com/device?user_code=WDJB-MJHT",

237 "expires_in": 600,

238 "interval": 5

239 }

240 ```

241 

242 Testen Sie drittens das Browser-Bein, indem Sie `verification_uri_complete` in einem Browser öffnen und den Code bestätigen. Sie sollten zur Anmeldungsseite Ihres IdP weitergeleitet werden, und nach der Anmeldung auf dem Gateway mit einer angemeldeten Bestätigung landen.

243 

244 Verwenden Sie die erste fehlgeschlagene Überprüfung, um das Problem zu lokalisieren:

245 

246 * **Erste Überprüfung schlägt fehl**: Der Start wurde nicht abgeschlossen; überprüfen Sie stderr

247 * **Zweite Überprüfung schlägt fehl**: Postgres ist vom Gateway nicht erreichbar oder die Rolle kann nicht schreiben; überprüfen Sie die Verbindungszeichenfolge und Berechtigungen

248 * **Dritte Überprüfung erreicht den IdP nicht**: Überprüfen Sie, dass der Redirect-URI des IdP genau `https://<gateway>/oauth/callback` entspricht

249 * **Dritte Überprüfung erreicht den IdP, springt aber mit einem Fehler zurück**: Lesen Sie das Audit-Protokoll des Gateways, das jede Auth-Ablehnung mit dem Grund aufzeichnet, z. B. `email domain not allowed`

250 </Step>

251 

252 <Step title="Melden Sie einen Entwickler an">

253 Dieser letzte Schritt erfolgt auf einer Entwicklermaschine, nicht auf dem Server. Setzen Sie `forceLoginMethod` auf `"gateway"` und `forceLoginGatewayUrl` auf die `public_url` Ihres Gateways in der [verwalteten Einstellungsdatei](/docs/de/settings#settings-files) dieser Maschine, führen Sie dann `/login` aus, drücken Sie Enter auf dem **Cloud gateway**-Bildschirm und schließen Sie die Browser-Anmeldung ab. [Gateway-URL festlegen](#set-the-gateway-url) unten behandelt die Verteilung beider Schlüssel im großen Maßstab.

254 </Step>

255</Steps>

256 

257<h2 id="connect-developers">

258 Entwickler verbinden

259</h2>

260 

261Entwickler verbinden sich von ihren eigenen Laptops mit einer Browser-Anmeldung, indem sie ihr Unternehmensarbeitskonto verwenden. Sie benötigen kein claude.ai-Konto, keinen API-Schlüssel und kein Abonnement, da Anfragen an das Modell über das Gateway mit den Upstream-Anmeldedaten der Organisation gehen. Die Verbindung wird durch die [clientseitigen verwalteten Einstellungen](/docs/de/claude-apps-gateway-config#client-side-managed-settings) gesteuert, die Sie über MDM pushen, daher gibt es keine manuelle Einrichtung auf der Entwicklerseite; dieser Abschnitt behandelt, was der Admin konfiguriert.

262 

263Die CLI fingerabdruckt das TLS-Blatt-Zertifikat des Gateways beim ersten Verbinden und heftet es pro Hostname an. Veröffentlichen Sie den erwarteten SHA-256-Fingerabdruck zusammen mit der Gateway-URL, damit Entwickler etwas zum Vergleichen haben. Rufen Sie den Fingerabdruck aus der Zertifikatsdatei mit `openssl x509 -noout -fingerprint -sha256 -in cert.pem` ab; die `/login`-Eingabeaufforderung zeigt die ersten 16 Zeichen des Digest als Kleinbuchstaben-Hexadezimal ohne Trennzeichen.

264 

265Wenn das Zertifikat rotiert, sieht jeder Entwickler die Vertrauensaufforderung erneut, daher behandeln Sie Rotationen als geplantes Ereignis und veröffentlichen Sie den Fingerabdruck erneut.

266 

267Nach der Anmeldung zeigt die [Modellauswahl](/docs/de/model-config) die Modelle in der `availableModels`-Zulassungsliste des Entwicklers, verwaltete Einstellungen werden beim Start angewendet und stündlich aktualisiert, und Telemetrie wird an Ihren Collector weitergeleitet. Sitzungen werden vor Ablauf von `ttl_hours` stillschweigend aktualisiert, und eine fehlgeschlagene Aktualisierung nach IdP-Entbereitstellung fordert eine erneute Anmeldung auf.

268 

269<h3 id="set-the-gateway-url">

270 Gateway-URL festlegen

271</h3>

272 

273Setzen Sie beide Schlüssel in der Pro-OS-[Datei mit verwalteten Einstellungen](/docs/de/settings#settings-files), die Sie über MDM oder direkt auf der Festplatte bereitstellen, und `/login` öffnet sich direkt auf dem **Cloud gateway**-Bildschirm mit der ausgefüllten URL:

274 

275```json theme={null}

276{

277 "forceLoginMethod": "gateway",

278 "forceLoginGatewayUrl": "https://claude-gateway.internal.example.com"

279}

280```

281 

282Der Entwickler drückt Enter, um sich zu verbinden. Die Fingerabdruck-Eingabeaufforderung beim ersten Verbinden wird immer noch angezeigt.

283 

284Es gibt keine Gateway-Option in der Anmeldungsauswahl für einen Entwickler, um manuell auszuwählen, und `forceLoginGatewayUrl` wird in den eigenen Einstellungsdateien eines Entwicklers ignoriert. `forceLoginMethod` allein, ohne URL, lässt den Entwickler bei einer "Kontaktieren Sie Ihren IT-Administrator"-Nachricht. Beide Schlüssel gehören in die Datei, die Sie auf Maschinen pushen, nicht in den `managed.policies[].cli`-Block des Gateways, der nur bereits verbundene Clients erreicht.

285 

286<h3 id="ci-pipelines-and-remote-machines">

287 CI-Pipelines und Remote-Maschinen

288</h3>

289 

290Es gibt keinen Service-Token-Fluss für unbeaufsichtigte Pipelines. Gateway-Anmeldung führt immer den Browser-Gerätefluss aus, daher kann ein CI-Job ohne Entwickler zur Genehmigung der Anmeldung nicht authentifizieren; konfigurieren Sie diese direkt gegen Ihren Anbieter. Sobald sich ein Entwickler angemeldet hat, verwendet jede Claude Code-Invokation auf dieser Maschine die Gateway-Sitzung, einschließlich nicht-interaktiver `claude -p`-Läufe und Sitzungen, die vom Agent SDK gestartet werden, und die [Gateway-Richtlinie gilt für alle davon](/docs/de/claude-apps-gateway-config#managed).

291 

292Der Gerätefluss trennt die Polling-CLI vom genehmigenden Browser, daher funktioniert eine Remote-Entwicklungsbox ohne Display immer noch: Der Entwickler führt `/login` über SSH auf der Remote-Maschine aus und öffnet den Überprüfungslink im Browser auf seinem Laptop.

293 

294<h3 id="what’s-enforced-on-developers">

295 Was auf Entwickler erzwungen wird

296</h3>

297 

298Diese Garantien gelten für jede angemeldete Gateway-Sitzung.

299 

300* **Modellzugriff**: Anfragen für Modelle, die die Richtlinie nicht gewährt, geben 400 zurück, und die `/model`-Auswahl wird auf die `availableModels`-Zulassungsliste der Richtlinie gefiltert. Setzen Sie [`enforceAvailableModels: true`](/docs/de/model-config#default-model-behavior) in der Richtlinie, damit die Standard-Option zu einem Modell in `availableModels` aufgelöst wird, anstatt zu Claude Codes integriertem Standard; ohne sie bleibt Standard wählbar und wird bei der Anfrageverarbeitung abgelehnt, wenn dieses Modell nicht gewährt wird.

301* **Telemetrie-Ziel**: Wenn [Telemetrie-Weiterleitung](/docs/de/claude-apps-gateway-config#telemetry) konfiguriert ist, wird der OTLP-Export-Endpunkt auf das Gateway angeheftet, und die vom Gateway gepushte Konfiguration überschreibt lokal gesetzte `OTEL_*`-Variablen.

302* **Anmeldedaten**: Das Gateway-Token ist die einzige Anmeldedaten der Sitzung. `ANTHROPIC_AUTH_TOKEN`, `ANTHROPIC_API_KEY`, `apiKeyHelper` und jede frühere claude.ai-Anmeldung werden ignoriert, während angemeldet, daher müssen sich Entwickler nicht zuerst von claude.ai abmelden.

303* **Verwaltete Einstellungen**: Gesperrte Schlüssel können nicht lokal überschrieben werden. Die CLI wendet die Richtlinie beim Start und bei jeder stündlichen Abfrage an.

304* **Startup**: Angemeldete Sitzungen beenden sich beim Start mit einem Fehler nach etwa 10 Sekunden, wenn das Gateway unerreichbar ist, anstatt ohne ihre Einstellungen zu starten.

305* **Entbereitstellung**: Eine Sitzung, deren Benutzer im IdP deaktiviert ist, läuft innerhalb von `ttl_hours` ab, wenn die nächste Aktualisierung fehlschlägt.

306 

307<h3 id="what-the-organization-can-see">

308 Was die Organisation sehen kann

309</h3>

310 

311Nutzungstelemetrie trägt die Identität des Entwicklers, Token-Zählungen, Modell und Latenz zum Collector der Organisation. Das Gateway protokolliert oder speichert keinen Prompt- oder Completion-Inhalt. Ob umfangreichere Telemetrie wie Protokolle und Traces erfasst wird, die Befehle und Dateipfade enthalten können, ist die [Pro-Ziel-Wahl](/docs/de/claude-apps-gateway-config#telemetry) der Organisation.

312 

313<h2 id="availability-and-limitations">

314 Verfügbarkeit und Einschränkungen

315</h2>

316 

317Die Tabelle behandelt, welche Claude-Code-Funktionen funktionieren, wenn Entwickler sich über das Gateway verbinden, und was der Gateway-Server selbst unterstützt. Wenn etwas nicht unterstützt wird, gibt die Spalte Notizen die Alternative an.

318 

319Das Gateway liefert die [`anthropic-beta`](https://platform.claude.com/docs/en/api/beta-headers)-Werte, die die CLI an jeden Upstream sendet, daher verwalten Operatoren keine Beta-Zulassungsliste. Für Amazon Bedrock, das den Header ignoriert, verschiebt das Gateway die Werte in das `anthropic_beta`-Feld des Request-Body; die anderen Upstreams erhalten den Header wie gesendet.

320 

321Das Gateway-Sitzungs-Beta-Set der CLI lässt First-Party-Only-Betas und die Extended-Cache-TTL-Beta aus, weshalb diese Zeilen unten als nicht verfügbar angezeigt werden.

322 

323| Funktion | Status | Notizen |

324| ------------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

325| Inferenz-Weiterleitung (Amazon Bedrock, Claude Platform auf AWS, Agent Platform von Google Cloud, Microsoft Foundry, Anthropic) | Verfügbar | Mit Pro-Upstream-Modellübersetzung und Failover. Der Amazon-Bedrock-Upstream verwendet den `bedrock-runtime`-Endpunkt und die AWS-Standard-Anmeldekette; der Amazon-Bedrock-[Mantle-Endpunkt](/docs/de/amazon-bedrock#use-the-mantle-endpoint) ist kein unterstützter Upstream. Der [Claude-Platform-auf-AWS-Upstream](/docs/de/claude-apps-gateway-config#claude-platform-on-aws) erfordert Claude Code v2.1.198 oder später auf dem Gateway-Server. |

326| Modellzugriff und verwaltete Einstellungen nach IdP-Gruppe | Verfügbar | Modellzugriff wird auf der Serverseite erzwungen; verwaltete Einstellungen werden pro IdP-Gruppe bereitgestellt und von der CLI auf der [Ebene der verwalteten Einstellungen](/docs/de/settings#settings-precedence) angewendet |

327| Telemetrie-Verteilung (OTLP/HTTP) | Verfügbar | Identitäts-gestempelt pro Export; sowohl Protobuf- als auch JSON-Codierungen |

328| OIDC-Identitätsanbieter | Verfügbar | Alle OIDC-konformen IdPs; das Gateway führt Standard-OIDC-Erkennung und den Authorization-Code-Flow durch. Siehe [Identitätsanbieter-Setup](/docs/de/claude-apps-gateway-deploy#identity-provider-setup) für Pro-IdP-Konfiguration |

329| Pro-Benutzer- und Pro-Gruppen-Ausgabenlimits | Verfügbar | Siehe [Ausgabenlimits](/docs/de/claude-apps-gateway-spend-limits) |

330| Serverseitige Websuche | Nicht verfügbar | Die CLI kann nicht sehen, welchen Upstream-Anbieter das Gateway leitet, daher kann sie Websuche-Unterstützung nicht überprüfen und deaktiviert WebSearch auf Gateway-Sitzungen |

331| Standard-Prompt-Caching | Verfügbar | `cache_control`-Breakpoints werden an jeden Upstream weitergeleitet |

332| 1-Stunden-Cache-TTL | Nicht verfügbar | Die CLI lässt die Extended-Cache-TTL-Beta auf Gateway-Sitzungen aus, da nicht jeder Upstream, zu dem das Gateway leiten kann, die 1-Stunden-TTL unterstützt, daher verwendet Prompt-Caching über das Gateway die 5-Minuten-TTL; siehe die Beta-Header-Notiz oben |

333| Auto-Modus | Verfügbar | Folgt den [Regeln für Drittanbieter-Anbieter](/docs/de/permission-modes#enable-auto-mode-on-bedrock-agent-platform-or-foundry): Nur die Modelle, die auf Drittanbieter-Anbietern berechtigt sind, können es verwenden. {/* min-version: 2.1.207 */}Vor v2.1.207 erforderte Auto-Modus auf Gateway-Sitzungen das Setzen von `CLAUDE_CODE_ENABLE_AUTO_MODE=1`, lieferbar über den verwalteten Richtlinien-`env`-Block |

334| First-Party-Only-Optimierungen wie globaler Cache-Umfang und Token-effiziente Tools | Nicht verfügbar | Die CLI aktiviert sie nicht auf Gateway-Sitzungen; siehe die Beta-Header-Notiz oben |

335| OTLP/gRPC | Nicht unterstützt | Nur OTLP über HTTP |

336| SAML, LDAP und andere nicht-OIDC-Auth | Nicht unterstützt | Nur OIDC. Front mit einer OIDC-Brücke, falls erforderlich |

337| Multi-Tenant (mehrere OIDC-Aussteller) | Nicht unterstützt | Ein Aussteller pro Gateway. Führen Sie separate Instanzen aus |

338| Windows-Server | Nicht unterstützt | Bereitstellung auf Linux. macOS nur für lokale Entwicklung |

339| Helm-Diagramm | Nicht verfügbar | Das Gateway läuft als Standard-Stateless-Deployment; siehe den [Bereitstellungsleitfaden](/docs/de/claude-apps-gateway-deploy#kubernetes) |

340| Admin-UI | Nicht verfügbar | Konfiguration ist die YAML-Datei; stellen Sie erneut bereit, um sie zu ändern |

341 

342<h2 id="next-steps">

343 Nächste Schritte

344</h2>

345 

346Der Schnellstart lässt Sie mit einer minimalen Konfiguration unter Docker Compose. Um es weiter zu bringen:

347 

348* Erweitern Sie `gateway.yaml` über die minimale Konfiguration hinaus, um beispielsweise Pro-Gruppen-RBAC, Multi-Upstream-Failover oder Telemetrie-Ziele hinzuzufügen. Die [Konfigurationsreferenz](/docs/de/claude-apps-gateway-config) behandelt jede Option.

349* Wechseln Sie von Compose zu einer Produktionsbereitstellung auf Kubernetes oder Cloud Run, richten Sie Ihren IdP ordnungsgemäß ein und überprüfen Sie das Sicherheitsmodell. Der [Bereitstellungs- und Operationsleitfaden](/docs/de/claude-apps-gateway-deploy) behandelt IdP-spezifische Einrichtung, Container-Image-Anforderungen, Health-Probes und Fehlerbehebung.

350* Legen Sie Ausgabengrenzen für einzelne Entwickler oder Gruppen fest, damit eine unkontrollierte Workload Ihre gesamte Verpflichtung nicht verbrauchen kann. [Ausgabenlimits](/docs/de/claude-apps-gateway-spend-limits) behandelt die Admin-API und wie die Durchsetzung funktioniert.

351* Für ein vollständiges durchgearbeitetes Beispiel auf Google Cloud mit Cloud Run, Cloud SQL und Secret Manager siehe [Bereitstellung auf Google Cloud](/docs/de/claude-apps-gateway-on-gcp).

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

4 

5# Claude Code hinter einem Corporate Launcher ausführen

6 

7> Leiten Sie die Prozesse, die Claude Code von seiner eigenen Binärdatei aus startet, einschließlich des Hintergrunddienstes und jeder Agent-View-Sitzung, durch einen erforderlichen Launcher mit CLAUDE_CODE_PROCESS_WRAPPER.

8 

9Einige Organisationen erfordern, dass jeder Prozess auf einer Workstation durch einen obligatorischen Launcher gestartet wird. Der Launcher wendet die Sandbox, Netzwerkkontrollen oder Credential-Injection an, auf die die Sicherheitsposition des Unternehmens angewiesen ist, und eine Binärdatei, die ohne diese startet, ist ein Verstoß gegen die Richtlinie.

10 

11`CLAUDE_CODE_PROCESS_WRAPPER` startet jeden Prozess, den Claude Code von seiner eigenen Binärdatei aus startet, durch Ihren Launcher: den Hintergrund­dienst, jede Sitzung, die er in [Agent View](/docs/de/agent-view) hostet, und Claude Codes Neustarts nach einem Update. Setzen Sie es auf den absoluten Pfad Ihres Launchers, und Claude Code führt den Launcher mit dem Claude-Code-Befehl als seine Argumente aus.

12 

13Ein Launcher, der den `claude`-Befehl auf Ihrem `PATH` umhüllt, kann diese Prozesse nicht erreichen, da sie vom direkten Pfad der Binärdatei aus starten, ohne `claude` nachzuschlagen.

14 

15<Note>

16 `CLAUDE_CODE_PROCESS_WRAPPER` erfordert Claude Code v2.1.208 oder später. Frühere Versionen ignorieren die Variable und starten jeden Prozess ohne Umhüllung.

17</Note>

18 

19<h2 id="what-the-launcher-covers">

20 Was der Launcher abdeckt

21</h2>

22 

23Mit `CLAUDE_CODE_PROCESS_WRAPPER` gesetzt startet Claude Code jeden der folgenden Prozesse durch Ihren Launcher:

24 

25* Der Hintergrund­dienst, den `claude agents` und Hintergrund­sitzungen bei Bedarf starten.

26* Der Terminal-Host und die Claude-Code-Sitzung in jeder Agent-View-Zeile, einschließlich der Warm-Standby-Sitzungen, die der Dienst bereit hält.

27* Sitzungen, die der Dienst nach einem Update oder Absturz neu startet.

28* Der Neustart, den Claude Code durchführt, um die Installation eines Updates abzuschließen, einschließlich der Restart-for-Update-Aktion von Agent View.

29 

30Unter Windows wird die Variable ignoriert: Der Launcher-Vertrag hängt von `exec` ab, das Windows nicht unterstützt. Ein Windows-Computer mit der gesetzten Variable führt jeden Prozess ohne Umhüllung aus und funktioniert weiterhin, und das einzige Signal ist eine Warnung im [Debug-Protokoll](/docs/de/troubleshooting). Wenn Ihre Launcher-Richtlinie Windows abdeckt, erfüllt die Variable sie dort nicht: Zählen Sie Windows-Computer als nicht umhüllt, wenn Sie den Rollout planen.

31 

32<h3 id="processes-that-start-outside-the-launcher">

33 Prozesse, die außerhalb des Launchers starten

34</h3>

35 

36Drei Prozesse starten niemals durch den Launcher:

37 

38* Ein [installierter Hintergrund­dienst](/docs/de/agent-view#the-supervisor-process): `launchd` oder `systemd` startet diesen Prozess aus seiner Unit-Datei. `/status` und `claude daemon status` warnen, wenn dies zutrifft, und die Sitzungen, die der Dienst startet, starten immer noch durch den Launcher, sobald der Dienst mit der Variable in seinen Einstellungen neu startet.

39* Eine Sitzung, die Sie selbst in einem Terminal starten, die so ausgeführt wird, wie Sie sie aufgerufen haben. Um diese Sitzungen abzudecken, legen Sie ein Skript namens `claude` in ein Verzeichnis früher auf `PATH`, das Ihren Launcher mit der echten Binärdatei ausführt; ersetzen Sie nicht den verwalteten Symlink. Self-Spawns konsultieren nicht `PATH`, daher stapeln sich die beiden Launcher nie.

40* Der erste Prozess eines `claude-cli://` Deep Links, den der Protokoll-Handler des Betriebssystems direkt startet. Alles, das diese Sitzung danach im Hintergrund startet, läuft durch den Launcher. Um diesen Pfad vollständig zu schließen, [verhindern Sie die Handler-Registrierung](/docs/de/deep-links#registration-and-supported-platforms) mit der Einstellung `disableDeepLinkRegistration`.

41 

42<h3 id="helper-process-names-in-process-monitors">

43 Namen von Hilfsprozessen in Prozessmonitoren

44</h3>

45 

46Mit einem konfigurierten Launcher zeigen `ps` und Activity Monitor den versionierten Binärnamen für die Hintergrund-Hilfsprozesse anstelle von Claude Codes `claude bg-pty-host` und `claude bg-spare` Labels an, da der `exec` des Launchers die Argumentliste neu erstellt. Die Umbenennung ist ein Nebeneffekt, keine Verschleierung: Die Prozesse sind ansonsten unverändert, und Claude Code identifiziert seine eigenen Prozesse nach Binärpfad, niemals nach Anzeigename.

47 

48<h2 id="set-up-the-launcher">

49 Richten Sie den Launcher ein

50</h2>

51 

52<Steps>

53 <Step title="Schreiben Sie das Launcher-Skript">

54 Erstellen Sie ein ausführbares Skript unter einem absoluten Pfad, z. B. `/opt/corp/launcher`. Claude Code führt es mit dem vollständigen Claude-Code-Befehl als seine Argumente aus, und das Skript muss mit `exec "$@"` enden, damit es sich selbst durch Claude Code ersetzt:

55 

56 ```bash theme={null}

57 #!/bin/sh

58 # Einrichtung Ihrer Organisation: Geben Sie die Sandbox ein, wenden Sie

59 # Netzwerkkontrollen an oder injizieren Sie Anmeldedaten.

60 exec "$@"

61 ```

62 

63 Machen Sie es mit `chmod +x` ausführbar. Der Einrichtungsteil ist das, was Ihr Launcher tun muss, bevor Claude Code ausgeführt wird; [der Launcher-Vertrag](#the-launcher-contract) unten listet die Regeln auf, die das Skript befolgen muss.

64 

65 <Note>

66 Wenn Sie zuvor den Symlink `~/.local/bin/claude` durch Ihren Launcher ersetzt haben, stellen Sie den ursprünglichen Symlink in derselben Änderung wieder her. Ein ersetzter Symlink führt dazu, dass die erste umhüllte Sitzung den Hintergrund­dienst gleichzeitig durch beide Launcher startet, und es versetzt die Installation in einen extern verwalteten Zustand: `/doctor` meldet dies, Auto-Update lässt die Datei an Ort und Stelle, und die Bereinigung alter Versionen bleibt deaktiviert, bis das Installationsprogramm diesen Pfad erneut verwaltet.

67 </Note>

68 </Step>

69 

70 <Step title="Setzen Sie CLAUDE_CODE_PROCESS_WRAPPER in den Einstellungen">

71 Setzen Sie die Variable im `env`-Block einer Einstellungsdatei, damit der abgelöste Hintergrund­dienst sie erbt. Ein Shell-`export` reicht nicht aus: Der Hintergrund­dienst startet bei Bedarf, überlebt Ihre Shell und liest Shell-Profile nie erneut.

72 

73 Für einen Computer fügen Sie es zu `~/.claude/settings.json` hinzu. Um es auf jedem Computer in Ihrer Organisation bereitzustellen, legen Sie denselben Block in [verwaltete Einstellungen](/docs/de/permissions#managed-settings):

74 

75 ```json theme={null}

76 {

77 "env": {

78 "CLAUDE_CODE_PROCESS_WRAPPER": "/opt/corp/launcher"

79 }

80 }

81 ```

82 

83 Wenn mehr als eine Quelle die Variable setzt, überschreibt der Wert der verwalteten Einstellungen sowohl `~/.claude/settings.json` als auch einen in der Shell exportierten Wert, sodass Benutzer Self-Spawns nicht auf einen anderen Launcher verweisen können.

84 

85 Projekt- und lokale Einstellungen können diese Variable nicht setzen. Eine Datei, die in ein Repository committed wird, darf nicht in der Lage sein, eine Binärdatei vor jedem Claude-Code-Prozess auf dem Computer zu platzieren, daher wird `CLAUDE_CODE_PROCESS_WRAPPER` in `.claude/settings.json` oder `.claude/settings.local.json` ignoriert, mit einer Warnung im [Debug-Protokoll](/docs/de/troubleshooting).

86 </Step>

87 

88 <Step title="Starten Sie den Hintergrund­dienst und Ihre Sitzungen neu">

89 Ein laufender Hintergrund­dienst und alle offenen `claude`-Sitzungen lesen die Variable einmal beim Start, daher starten sie weiterhin Prozesse ohne Umhüllung, bis sie neu gestartet werden. Führen Sie `claude daemon stop --any` aus, um den On-Demand-Dienst zu stoppen; der nächste Befehl, der ihn benötigt, z. B. `claude agents`, startet einen umhüllten. Ein [installierter Dienst](/docs/de/agent-view#the-supervisor-process) nimmt `claude daemon stop` ohne `--any`. Starten Sie dann Ihre offenen `claude`-Sitzungen neu.

90 

91 Auf Computern, die Sie nicht von Hand neu starten können, zieht die erste Sitzung, die nach dem Einstellungs-Push gestartet wird, automatisch einen verbleibenden On-Demand-Dienst ohne Umhüllung zurück. Ein Computer, auf dem keine neue Sitzung startet, behält seinen Dienst ohne Umhüllung, bis eine startet, und ein installierter Dienst benötigt immer den Neustart in diesem Schritt.

92 </Step>

93 

94 <Step title="Überprüfen">

95 Führen Sie `/status` in einer Sitzung aus: Der Self-exec-Eintrag zeigt den aufgelösten Startbefehl und warnt, wenn der laufende Hintergrund­dienst nicht damit übereinstimmt. `claude daemon status` gibt dieselben Informationen aus der Shell aus, auch nachdem Sie die Variable aufgehoben haben, wenn `/status` den Eintrag nicht mehr anzeigt.

96 </Step>

97</Steps>

98 

99<h2 id="the-launcher-contract">

100 Der Launcher-Vertrag

101</h2>

102 

103Wenn der Launcher nicht ausgeführt werden kann, weigert sich Claude Code, den Prozess zu starten, anstatt ihn ohne Umhüllung zu starten. Unter Windows wird [die Variable ignoriert](#what-the-launcher-covers) und Prozesse starten ohne Umhüllung. Claude Code hält das Skript an diese Regeln:

104 

105* **Enden Sie mit `exec "$@"`**. Ein Launcher, der ein Kind forkt und beendet, hinterlässt einen verwaisten Claude-Code-Prozess, den der Hintergrund­dienst nicht verfolgen kann. Agent View markiert eine solche Sitzung als fehlgeschlagen mit einer Nachricht, die den Launcher benennt, und der Dienst räumt auf, was der Launcher hinterlassen hat.

106* **Ordnen Sie Argumente nicht neu an, absorbieren oder stellen Sie ihnen voran**. Das erste Argument ist die Claude-Code-Binärdatei und alles danach ist sein argv.

107* **Geben Sie jede geerbte Umgebungsvariable an `exec` weiter**. Das Hinzufügen von Variablen, z. B. injizierte Anmeldedaten, ist in Ordnung; das Löschen geerbter ist nicht.

108 * Die Pro-Sitzungs-Authentifizierungstoken, die Modell- und Anbieterauswahl und `CLAUDE_CODE_PROCESS_WRAPPER` selbst reisen alle in der geerbten Umgebung, daher bricht ein Launcher, der sie aus einer Zulassungsliste neu erstellt, die Sitzungen, die er startet, und `/status` meldet eine Launcher-Nichtübereinstimmung.

109 * Wenn der Launcher einen Namespace oder eine Sandbox betreten muss, die die Umgebung zurückgesetzt, exportieren Sie die geerbte Umgebung darin wörtlich erneut.

110* **Erreichen Sie `exec` innerhalb von etwa drei Sekunden jedes Mal, wenn der Launcher ausgeführt wird**. Ein kalter Hintergrund-Dispatch führt den Launcher zweimal hintereinander aus, bevor das erste Byte der Ausgabe, daher führen Sie langsame Arbeiten wie einen Single-Sign-On-Austausch träge oder aus einem Cache durch.

111 * Ein Launcher, der weit über das Budget hinausgeht, wird als stagnierter Start behandelt und neu gestartet.

112* **Tolerieren Sie, dass Sie von innen aufgerufen werden**. Claude Code wendet den Launcher auf jeden verschachtelten Self-Spawn an, daher muss ein Launcher, der eine exklusive Ressource erwirbt, erkennen, dass er sie bereits hält.

113* **Schreiben Sie nicht auf das Terminal, bevor Claude Code startet**. Alles, das vor dem `exec` gedruckt wird, wird als Absturzursache gemeldet, wenn die Sitzung vor der Initialisierung stirbt.

114 

115<h3 id="format-of-the-claude_code_process_wrapper-value">

116 Format des `CLAUDE_CODE_PROCESS_WRAPPER`-Wertes

117</h3>

118 

119Für die meisten Launcher ist der Wert einfach der absolute Pfad des Skripts, z. B. `/opt/corp/launcher`.

120 

121Um Ihrem Launcher eigene Argumente zu übergeben, schreiben Sie sie nach dem Pfad. Claude Code analysiert den Wert als Argumentliste, nicht als Shell-Befehl:

122 

123* Whitespace trennt Token, und doppelte Anführungszeichen gruppieren ein Token, das Leerzeichen enthält.

124* Ein Wert, der mit `[` beginnt, wird als JSON-String-Array gelesen, z. B. `["/opt/corp/launcher", "--profile", "cc"]`.

125* Shell-Syntax funktioniert nicht: Es gibt keine Variablenerweiterung oder Globbing, und ein unquotierter Operator wie `;`, `|`, `&` oder `$(` wird als Konfigurationsfehler abgelehnt, anstatt neu interpretiert zu werden.

126 

127Wenn der Wert nicht verwendet werden kann, weigert sich Claude Code, den betroffenen Prozess zu starten, und [meldet den Grund](/docs/de/errors#claude_code_process_wrapper-launcher-errors).

128 

129<h2 id="relationship-to-claude_code_shell_prefix">

130 Beziehung zu `CLAUDE_CODE_SHELL_PREFIX`

131</h2>

132 

133`CLAUDE_CODE_PROCESS_WRAPPER` umhüllt Claude Codes eigene Prozesse und übergibt den Befehl als separate argv-Token an den Launcher zum `exec`. [`CLAUDE_CODE_SHELL_PREFIX`](/docs/de/env-vars) umhüllt die Shell-Befehle, die Claude in Ihrem Namen ausführt, z. B. Bash-Tool-Aufrufe, Hooks und die Befehle, die stdio-MCP-Server starten, und übergibt jeden als einzelne Shell-zitierte Zeichenkette in `$1` an den Wrapper zur Neubewertung. Ein für einen geschriebener Launcher funktioniert nicht als der andere.

134 

135<h2 id="related-resources">

136 Verwandte Ressourcen

137</h2>

138 

139* [Agent View](/docs/de/agent-view): die Hintergrund­sitzungen und der Supervisor-Prozess, den der Launcher abdeckt

140* [Umgebungsvariablen](/docs/de/env-vars): der `CLAUDE_CODE_PROCESS_WRAPPER`-Referenzeintrag

141* [Verwaltete Einstellungen](/docs/de/permissions#managed-settings): Liefern Sie den `env`-Block über eine Flotte

142* [Launcher-Fehlerreferenz](/docs/de/errors#claude_code_process_wrapper-launcher-errors): die Verweigerungsmeldungen und wie man sich erholt

12 12 

13<Warning>13<Warning>

14 Obwohl der Entwicklungscontainer erhebliche Schutzmaßnahmen bietet, ist kein System vollständig immun gegen alle Angriffe.14 Obwohl der Entwicklungscontainer erhebliche Schutzmaßnahmen bietet, ist kein System vollständig immun gegen alle Angriffe.

15 Bei Ausführung mit `--dangerously-skip-permissions` verhindern Entwicklungscontainer nicht, dass ein bösartiges Projekt alles exfiltriert, das im Container zugänglich ist, einschließlich der Claude Code-Anmeldedaten, die in [`~/.claude`](/de/claude-directory) gespeichert sind.15 Bei Ausführung mit `--dangerously-skip-permissions` verhindern Entwicklungscontainer nicht, dass ein bösartiges Projekt alles exfiltriert, das im Container zugänglich ist, einschließlich der Claude Code-Anmeldedaten, die in [`~/.claude`](/docs/de/claude-directory) gespeichert sind.

16 Verwenden Sie Entwicklungscontainer nur bei der Entwicklung mit vertrauenswürdigen Repositories, und überwachen Sie die Aktivitäten von Claude.16 Verwenden Sie Entwicklungscontainer nur bei der Entwicklung mit vertrauenswürdigen Repositories, und überwachen Sie die Aktivitäten von Claude.

17 Vermeiden Sie das Einbinden von Host-Geheimnissen wie `~/.ssh` oder Cloud-Anmeldedatendateien in den Container; bevorzugen Sie Repository-bezogene oder kurzlebige Token.17 Vermeiden Sie das Einbinden von Host-Geheimnissen wie `~/.ssh` oder Cloud-Anmeldedatendateien in den Container; bevorzugen Sie Repository-bezogene oder kurzlebige Token.

18</Warning>18</Warning>

20<Accordion title="Wie Entwicklungscontainer mit Ihrem Editor funktionieren">20<Accordion title="Wie Entwicklungscontainer mit Ihrem Editor funktionieren">

21 <img src="https://mintcdn.com/claude-code/YvJyjZfd9yMihr0i/images/devcontainer-architecture.svg?fit=max&auto=format&n=YvJyjZfd9yMihr0i&q=85&s=9017b1d16a446c6cc37ba562f35b9aae" className="dark:hidden" alt="Diagramm, das einen Editor auf dem Host zeigt, der sich mit einem Docker-Entwicklungscontainer verbindet. Claude Code, das Terminal und Build-Tools werden im Container ausgeführt. Das Host-Repository wird als Arbeitsbereich in den Container eingebunden." width="640" height="300" data-path="images/devcontainer-architecture.svg" />21 <img src="https://mintcdn.com/claude-code/YvJyjZfd9yMihr0i/images/devcontainer-architecture.svg?fit=max&auto=format&n=YvJyjZfd9yMihr0i&q=85&s=9017b1d16a446c6cc37ba562f35b9aae" className="dark:hidden" alt="Diagramm, das einen Editor auf dem Host zeigt, der sich mit einem Docker-Entwicklungscontainer verbindet. Claude Code, das Terminal und Build-Tools werden im Container ausgeführt. Das Host-Repository wird als Arbeitsbereich in den Container eingebunden." width="640" height="300" data-path="images/devcontainer-architecture.svg" />

22 22 

23 <img src="https://mintcdn.com/claude-code/YvJyjZfd9yMihr0i/images/devcontainer-architecture-dark.svg?fit=max&auto=format&n=YvJyjZfd9yMihr0i&q=85&s=ef00c8e25b1ea7a3a152895f1488831b" className="hidden dark:block" alt="Diagramm, das einen Editor auf dem Host zeigt, der sich mit einem Docker-Entwicklungscontainer verbindet. Claude Code, das Terminal und Build-Tools werden im Container ausgeführt. Das Host-Repository wird als Arbeitsbereich in den Container eingebunden." width="640" height="300" data-path="images/devcontainer-architecture-dark.svg" />23 <img src="https://mintcdn.com/claude-code/_xqph1dUOslCOwsj/images/devcontainer-architecture-dark.svg?fit=max&auto=format&n=_xqph1dUOslCOwsj&q=85&s=a0a340b1f2afc6a590696102c8acaaca" className="hidden dark:block" alt="Diagramm, das einen Editor auf dem Host zeigt, der sich mit einem Docker-Entwicklungscontainer verbindet. Claude Code, das Terminal und Build-Tools werden im Container ausgeführt. Das Host-Repository wird als Arbeitsbereich in den Container eingebunden." width="640" height="300" data-path="images/devcontainer-architecture-dark.svg" />

24 24 

25 Ein Entwicklungscontainer wird als Docker-Container ausgeführt, entweder auf Ihrem Rechner oder auf einem Cloud-Host wie GitHub Codespaces. Ein Editor, der die Dev Containers-Spezifikation unterstützt, wie VS Code, GitHub Codespaces, eine JetBrains IDE oder Cursor, verbindet sich mit diesem Container: Sie durchsuchen und bearbeiten Dateien im Editor wie gewohnt, aber das integrierte Terminal, die Sprachserver und Build-Tools werden alle im Container ausgeführt, anstatt auf Ihrem Host. Editoren ohne Dev Container-Unterstützung, wie einfaches Vim, sind nicht Teil dieses Workflows.25 Ein Entwicklungscontainer wird als Docker-Container ausgeführt, entweder auf Ihrem Rechner oder auf einem Cloud-Host wie GitHub Codespaces. Ein Editor, der die Dev Containers-Spezifikation unterstützt, wie VS Code, GitHub Codespaces, eine JetBrains IDE oder Cursor, verbindet sich mit diesem Container: Sie durchsuchen und bearbeiten Dateien im Editor wie gewohnt, aber das integrierte Terminal, die Sprachserver und Build-Tools werden alle im Container ausgeführt, anstatt auf Ihrem Host. Editoren ohne Dev Container-Unterstützung, wie einfaches Vim, sind nicht Teil dieses Workflows.

26 26 

27 Claude Code wird im Container ausgeführt, daher sieht es die gleichen Dateien, Abhängigkeiten und Tools wie der Rest Ihres Projekt-Toolchains. In VS Code können Sie entweder das [Claude Code-Erweiterungspanel](/de/vs-code) verwenden oder `claude` im integrierten Terminal ausführen; beide werden im Container ausgeführt und teilen die gleiche `~/.claude`-Konfiguration.27 Claude Code wird im Container ausgeführt, daher sieht es die gleichen Dateien, Abhängigkeiten und Tools wie der Rest Ihres Projekt-Toolchains. In VS Code können Sie entweder das [Claude Code-Erweiterungspanel](/docs/de/vs-code) verwenden oder `claude` im integrierten Terminal ausführen; beide werden im Container ausgeführt und teilen die gleiche `~/.claude`-Konfiguration.

28</Accordion>28</Accordion>

29 29 

30<h2 id="add-claude-code-to-your-dev-container">30<h2 id="add-claude-code-to-your-dev-container">

75Was Sie bei der Authentifizierungsaufforderung sehen, hängt von Ihrem Anbieter ab:75Was Sie bei der Authentifizierungsaufforderung sehen, hängt von Ihrem Anbieter ab:

76 76 

77* **Anthropic**: Melden Sie sich über einen Browser mit Ihrem Claude- oder Anthropic Console-Konto an77* **Anthropic**: Melden Sie sich über einen Browser mit Ihrem Claude- oder Anthropic Console-Konto an

78* **[Amazon Bedrock, Google Cloud's Agent Platform oder Microsoft Foundry](/de/third-party-integrations)**: Claude Code verwendet Ihre Cloud-Anbieter-Anmeldedaten, ohne Browser-Aufforderung78* **[Amazon Bedrock, Google Cloud's Agent Platform oder Microsoft Foundry](/docs/de/third-party-integrations)**: Claude Code verwendet Ihre Cloud-Anbieter-Anmeldedaten, ohne Browser-Aufforderung

79 79 

80Für Cloud-Anbieter übergeben Sie Anmeldedaten an den Container als Umgebungsvariablen über `containerEnv`, ein Codespaces-Geheimnis oder die Workload-Identität Ihrer Cloud, anstatt Anmeldedatendateien vom Host einzubinden. Siehe [Amazon Bedrock](/de/amazon-bedrock), [Google Cloud's Agent Platform](/de/google-vertex-ai) oder [Microsoft Foundry](/de/microsoft-foundry) für die Anmeldedatenkette, die Claude Code liest.80Für Cloud-Anbieter übergeben Sie Anmeldedaten an den Container als Umgebungsvariablen über `containerEnv`, ein Codespaces-Geheimnis oder die Workload-Identität Ihrer Cloud, anstatt Anmeldedatendateien vom Host einzubinden. Siehe [Amazon Bedrock](/docs/de/amazon-bedrock), [Google Cloud's Agent Platform](/docs/de/google-vertex-ai) oder [Microsoft Foundry](/docs/de/microsoft-foundry) für die Anmeldedatenkette, die Claude Code liest.

81 81 

82Siehe [Wählen Sie Ihren API-Anbieter](/de/admin-setup#choose-your-api-provider), um zu entscheiden, welcher Weg zu Ihrer Organisation passt.82Siehe [Wählen Sie Ihren API-Anbieter](/docs/de/admin-setup#choose-your-api-provider), um zu entscheiden, welcher Weg zu Ihrer Organisation passt.

83 83 

84<Note>84<Note>

85 Wenn die Browser-Anmeldung abgeschlossen ist, aber der Rückruf den Container nie erreicht, kopieren Sie den im Browser angezeigten Code und fügen Sie ihn bei der Aufforderung `Paste code here if prompted` im Terminal ein. Dies kann vorkommen, wenn die Port-Weiterleitung des Editors den localhost-Rückruf nicht leitet.85 Wenn die Browser-Anmeldung abgeschlossen ist, aber der Rückruf den Container nie erreicht, kopieren Sie den im Browser angezeigten Code und fügen Sie ihn bei der Aufforderung `Paste code here if prompted` im Terminal ein. Dies kann vorkommen, wenn die Port-Weiterleitung des Editors den localhost-Rückruf nicht leitet.

89 Authentifizierung und Einstellungen über Neuerstellungen hinweg beibehalten89 Authentifizierung und Einstellungen über Neuerstellungen hinweg beibehalten

90</h2>90</h2>

91 91 

92Standardmäßig wird das Home-Verzeichnis des Containers bei einer Neuerstellung verworfen, daher müssen sich Ingenieure jedes Mal erneut anmelden. Claude Code speichert sein Authentifizierungs-Token, Benutzereinstellungen und Sitzungsverlauf unter [`~/.claude`](/de/claude-directory). Binden Sie ein benanntes Volume an diesem Pfad ein, um diesen Status über Neuerstellungen hinweg zu bewahren.92Standardmäßig wird das Home-Verzeichnis des Containers bei einer Neuerstellung verworfen, daher müssen sich Ingenieure jedes Mal erneut anmelden. Claude Code speichert sein Authentifizierungs-Token, Benutzereinstellungen und Sitzungsverlauf unter [`~/.claude`](/docs/de/claude-directory). Binden Sie ein benanntes Volume an diesem Pfad ein, um diesen Status über Neuerstellungen hinweg zu bewahren.

93 93 

94Das folgende Beispiel bindet ein Volume im Home-Verzeichnis des `node`-Benutzers ein:94Das folgende Beispiel bindet ein Volume im Home-Verzeichnis des `node`-Benutzers ein:

95 95 

99]99]

100```100```

101 101 

102Ersetzen Sie `/home/node` durch das Home-Verzeichnis des `remoteUser` Ihres Containers. Wenn Sie das Volume an einem anderen Ort als `~/.claude` einbinden, setzen Sie [`CLAUDE_CONFIG_DIR`](/de/env-vars) auf den Mount-Pfad, damit Claude Code dort liest und schreibt.102Ersetzen Sie `/home/node` durch das Home-Verzeichnis des `remoteUser` Ihres Containers. Wenn Sie das Volume an einem anderen Ort als `~/.claude` einbinden, setzen Sie [`CLAUDE_CONFIG_DIR`](/docs/de/env-vars) auf den Mount-Pfad, damit Claude Code dort liest und schreibt.

103 103 

104Um den Status pro Projekt zu isolieren, anstatt ein Volume über alle Repositories hinweg zu teilen, fügen Sie die Variable `${devcontainerId}` in den Quellnamen ein. Die [Referenzkonfiguration](https://github.com/anthropics/claude-code/blob/main/.devcontainer/devcontainer.json) verwendet `source=claude-code-config-${devcontainerId}` zu diesem Zweck.104Um den Status pro Projekt zu isolieren, anstatt ein Volume über alle Repositories hinweg zu teilen, fügen Sie die Variable `${devcontainerId}` in den Quellnamen ein. Die [Referenzkonfiguration](https://github.com/anthropics/claude-code/blob/main/.devcontainer/devcontainer.json) verwendet `source=claude-code-config-${devcontainerId}` zu diesem Zweck.

105 105 

106In GitHub Codespaces bleibt `~/.claude` über das Stoppen und Starten eines Codespace erhalten, wird aber immer noch gelöscht, wenn Sie den Container neu erstellen, daher gilt die obige Volume-Einbindung auch dort. Um die Authentifizierung über Codespaces hinweg zu tragen, speichern Sie `ANTHROPIC_API_KEY` oder ein `CLAUDE_CODE_OAUTH_TOKEN` von [`claude setup-token`](/de/authentication#generate-a-long-lived-token) als [Codespaces-Geheimnis](https://docs.github.com/en/codespaces/managing-your-codespaces/managing-your-account-specific-secrets-for-github-codespaces); Codespaces macht Geheimnisse automatisch als Umgebungsvariablen im Container verfügbar.106In GitHub Codespaces bleibt `~/.claude` über das Stoppen und Starten eines Codespace erhalten, wird aber immer noch gelöscht, wenn Sie den Container neu erstellen, daher gilt die obige Volume-Einbindung auch dort. Um die Authentifizierung über Codespaces hinweg zu tragen, speichern Sie `ANTHROPIC_API_KEY` oder ein `CLAUDE_CODE_OAUTH_TOKEN` von [`claude setup-token`](/docs/de/authentication#generate-a-long-lived-token) als [Codespaces-Geheimnis](https://docs.github.com/en/codespaces/managing-your-codespaces/managing-your-account-specific-secrets-for-github-codespaces); Codespaces macht Geheimnisse automatisch als Umgebungsvariablen im Container verfügbar.

107 107 

108<h2 id="enforce-organization-policy">108<h2 id="enforce-organization-policy">

109 Organisationsrichtlinie durchsetzen109 Organisationsrichtlinie durchsetzen

111 111 

112Ein Entwicklungscontainer ist ein bequemer Ort, um Organisationsrichtlinie anzuwenden, da das gleiche Image und die gleiche Konfiguration auf jedem Rechner eines Ingenieurs ausgeführt werden.112Ein Entwicklungscontainer ist ein bequemer Ort, um Organisationsrichtlinie anzuwenden, da das gleiche Image und die gleiche Konfiguration auf jedem Rechner eines Ingenieurs ausgeführt werden.

113 113 

114Claude Code liest `/etc/claude-code/managed-settings.json` auf Linux und wendet es mit der höchsten Priorität in der [Einstellungshierarchie](/de/settings#how-scopes-interact) an, daher überschreiben Werte dort alles, das ein Ingenieur in `~/.claude` oder dem `.claude/`-Verzeichnis des Projekts setzt. Kopieren Sie die Datei von Ihrem Dockerfile an den richtigen Ort:114Claude Code liest `/etc/claude-code/managed-settings.json` auf Linux und wendet es mit der höchsten Priorität in der [Einstellungshierarchie](/docs/de/settings#how-scopes-interact) an, daher überschreiben Werte dort alles, das ein Ingenieur in `~/.claude` oder dem `.claude/`-Verzeichnis des Projekts setzt. Kopieren Sie die Datei von Ihrem Dockerfile an den richtigen Ort:

115 115 

116```dockerfile Dockerfile theme={null}116```dockerfile Dockerfile theme={null}

117RUN mkdir -p /etc/claude-code117RUN mkdir -p /etc/claude-code

118COPY managed-settings.json /etc/claude-code/managed-settings.json118COPY managed-settings.json /etc/claude-code/managed-settings.json

119```119```

120 120 

121Da das Dockerfile im Repository lebt, kann jeder mit Schreibzugriff diesen Schritt ändern oder entfernen. Für Richtlinien, die Ingenieure nicht umgehen können, indem sie Repository-Dateien bearbeiten, liefern Sie verwaltete Einstellungen über [server-verwaltete Einstellungen](/de/server-managed-settings) oder Ihr MDM statt. Siehe [verwaltete Einstellungsdateien](/de/settings#settings-files) für die verfügbaren Schlüssel und die anderen Lieferwege.121Da das Dockerfile im Repository lebt, kann jeder mit Schreibzugriff diesen Schritt ändern oder entfernen. Für Richtlinien, die Ingenieure nicht umgehen können, indem sie Repository-Dateien bearbeiten, liefern Sie verwaltete Einstellungen über [server-verwaltete Einstellungen](/docs/de/server-managed-settings) oder Ihr MDM statt. Siehe [verwaltete Einstellungsdateien](/docs/de/settings#settings-files) für die verfügbaren Schlüssel und die anderen Lieferwege.

122 122 

123Um [Umgebungsvariablen](/de/env-vars) zu setzen, die für jede Claude Code-Sitzung im Container gelten, fügen Sie sie zu `containerEnv` in Ihrer `devcontainer.json` hinzu. Das folgende Beispiel deaktiviert Telemetrie und Fehlerberichterstattung und verhindert, dass Claude Code sich nach der Installation automatisch aktualisiert:123Um [Umgebungsvariablen](/docs/de/env-vars) zu setzen, die für jede Claude Code-Sitzung im Container gelten, fügen Sie sie zu `containerEnv` in Ihrer `devcontainer.json` hinzu. Das folgende Beispiel deaktiviert Telemetrie und Fehlerberichterstattung und verhindert, dass Claude Code sich nach der Installation automatisch aktualisiert:

124 124 

125```json devcontainer.json theme={null}125```json devcontainer.json theme={null}

126"containerEnv": {126"containerEnv": {

131 131 

132Die Dev Container Feature installiert immer die neueste Claude Code-Version. Um eine bestimmte Claude Code-Version für reproduzierbare Builds zu fixieren, installieren Sie sie von Ihrem Dockerfile mit `npm install -g @anthropic-ai/claude-code@X.Y.Z`, anstatt die Feature zu verwenden, und setzen Sie `DISABLE_AUTOUPDATER` wie oben gezeigt.132Die Dev Container Feature installiert immer die neueste Claude Code-Version. Um eine bestimmte Claude Code-Version für reproduzierbare Builds zu fixieren, installieren Sie sie von Ihrem Dockerfile mit `npm install -g @anthropic-ai/claude-code@X.Y.Z`, anstatt die Feature zu verwenden, und setzen Sie `DISABLE_AUTOUPDATER` wie oben gezeigt.

133 133 

134Für die vollständige Liste der Richtlinienkontrollen, einschließlich Berechtigungsregeln, Tool-Einschränkungen und MCP-Server-Allowlists, siehe [Richten Sie Claude Code für Ihre Organisation ein](/de/admin-setup).134Für die vollständige Liste der Richtlinienkontrollen, einschließlich Berechtigungsregeln, Tool-Einschränkungen und MCP-Server-Allowlists, siehe [Richten Sie Claude Code für Ihre Organisation ein](/docs/de/admin-setup).

135 135 

136Um [MCP-Server](/de/mcp) im Container verfügbar zu machen, definieren Sie sie im [Projekt-Scope](/de/mcp#mcp-installation-scopes) in einer `.mcp.json`-Datei im Repository-Root, damit sie zusammen mit Ihrer Dev Container-Konfiguration eingecheckt werden. Installieren Sie alle Binärdateien, von denen lokale Stdio-Server abhängen, in Ihrem Dockerfile, und fügen Sie Remote-Server-Domains zu Ihrer Netzwerk-Allowlist hinzu.136Um [MCP-Server](/docs/de/mcp) im Container verfügbar zu machen, definieren Sie sie im [Projekt-Scope](/docs/de/mcp#mcp-installation-scopes) in einer `.mcp.json`-Datei im Repository-Root, damit sie zusammen mit Ihrer Dev Container-Konfiguration eingecheckt werden. Installieren Sie alle Binärdateien, von denen lokale Stdio-Server abhängen, in Ihrem Dockerfile, und fügen Sie Remote-Server-Domains zu Ihrer Netzwerk-Allowlist hinzu.

137 137 

138<h2 id="restrict-network-egress">138<h2 id="restrict-network-egress">

139 Netzwerk-Egress einschränken139 Netzwerk-Egress einschränken

140</h2>140</h2>

141 141 

142Sie können den ausgehenden Datenverkehr des Containers auf nur die Domains beschränken, die Claude Code benötigt. Siehe [Netzwerkzugriffsanforderungen](/de/network-config#network-access-requirements) für die Inferenz- und Authentifizierungsdomains, und [Telemetrie-Dienste](/de/data-usage#telemetry-services) für die optionalen Telemetrie- und Fehlerberichterstattungsverbindungen und wie man sie deaktiviert.142Sie können den ausgehenden Datenverkehr des Containers auf nur die Domains beschränken, die Claude Code benötigt. Siehe [Netzwerkzugriffsanforderungen](/docs/de/network-config#network-access-requirements) für die Inferenz- und Authentifizierungsdomains, und [Telemetrie-Dienste](/docs/de/data-usage#telemetry-services) für die optionalen Telemetrie- und Fehlerberichterstattungsverbindungen und wie man sie deaktiviert.

143 143 

144Der Referenz-Container enthält ein [`init-firewall.sh`](https://github.com/anthropics/claude-code/blob/main/.devcontainer/init-firewall.sh)-Skript, das den gesamten ausgehenden Datenverkehr außer den Domains blockiert, die Claude Code und Ihre Entwicklungstools benötigen. Das Ausführen einer Firewall in einem Container erfordert zusätzliche Berechtigungen, daher fügt die Referenz die `NET_ADMIN`- und `NET_RAW`-Fähigkeiten über `runArgs` hinzu. Das Firewall-Skript und diese Fähigkeiten sind nicht erforderlich für Claude Code selbst: Sie können sie weglassen und sich stattdessen auf Ihre eigenen Netzwerkkontrollen verlassen.144Der Referenz-Container enthält ein [`init-firewall.sh`](https://github.com/anthropics/claude-code/blob/main/.devcontainer/init-firewall.sh)-Skript, das den gesamten ausgehenden Datenverkehr außer den Domains blockiert, die Claude Code und Ihre Entwicklungstools benötigen. Das Ausführen einer Firewall in einem Container erfordert zusätzliche Berechtigungen, daher fügt die Referenz die `NET_ADMIN`- und `NET_RAW`-Fähigkeiten über `runArgs` hinzu. Das Firewall-Skript und diese Fähigkeiten sind nicht erforderlich für Claude Code selbst: Sie können sie weglassen und sich stattdessen auf Ihre eigenen Netzwerkkontrollen verlassen.

145 145 

151 151 

152Das Überspringen von Berechtigungsaufforderungen entfernt Ihre Gelegenheit, Tool-Aufrufe zu überprüfen, bevor sie ausgeführt werden. Claude kann immer noch jede Datei im eingebundenen Arbeitsbereich ändern, die direkt auf Ihrem Host angezeigt wird, und alles erreichen, das die Netzwerkrichtlinie des Containers erlaubt. Kombinieren Sie dieses Flag mit den [Netzwerk-Egress-Einschränkungen](#restrict-network-egress) oben, um zu begrenzen, was eine umgangene Sitzung erreichen kann.152Das Überspringen von Berechtigungsaufforderungen entfernt Ihre Gelegenheit, Tool-Aufrufe zu überprüfen, bevor sie ausgeführt werden. Claude kann immer noch jede Datei im eingebundenen Arbeitsbereich ändern, die direkt auf Ihrem Host angezeigt wird, und alles erreichen, das die Netzwerkrichtlinie des Containers erlaubt. Kombinieren Sie dieses Flag mit den [Netzwerk-Egress-Einschränkungen](#restrict-network-egress) oben, um zu begrenzen, was eine umgangene Sitzung erreichen kann.

153 153 

154Wenn Sie weniger Aufforderungen ohne Deaktivierung von Sicherheitsprüfungen möchten, erwägen Sie stattdessen [Auto-Modus](/de/permission-modes#eliminate-prompts-with-auto-mode), der einen Klassifizierer hat, der Aktionen überprüft, bevor sie ausgeführt werden. Um zu verhindern, dass Ingenieure `--dangerously-skip-permissions` überhaupt verwenden, setzen Sie `permissions.disableBypassPermissionsMode` auf `"disable"` in [verwalteten Einstellungen](/de/settings#permission-settings).154Wenn Sie weniger Aufforderungen ohne Deaktivierung von Sicherheitsprüfungen möchten, erwägen Sie stattdessen [Auto-Modus](/docs/de/permission-modes#eliminate-prompts-with-auto-mode), der einen Klassifizierer hat, der Aktionen überprüft, bevor sie ausgeführt werden. Um zu verhindern, dass Ingenieure `--dangerously-skip-permissions` überhaupt verwenden, setzen Sie `permissions.disableBypassPermissionsMode` auf `"disable"` in [verwalteten Einstellungen](/docs/de/settings#permission-settings).

155 155 

156<h2 id="try-the-reference-container">156<h2 id="try-the-reference-container">

157 Probieren Sie den Referenz-Container aus157 Probieren Sie den Referenz-Container aus

193 193 

194Sobald Claude Code in Ihrem Entwicklungscontainer ausgeführt wird, behandeln die folgenden Seiten den Rest eines Organisations-Rollouts: Auswahl eines Authentifizierungswegs, Lieferung verwalteter Richtlinien außerhalb des Repositories, Überwachung der Nutzung und Verständnis dessen, was Claude Code speichert und sendet.194Sobald Claude Code in Ihrem Entwicklungscontainer ausgeführt wird, behandeln die folgenden Seiten den Rest eines Organisations-Rollouts: Auswahl eines Authentifizierungswegs, Lieferung verwalteter Richtlinien außerhalb des Repositories, Überwachung der Nutzung und Verständnis dessen, was Claude Code speichert und sendet.

195 195 

196* [Richten Sie Claude Code für Ihre Organisation ein](/de/admin-setup): Wählen Sie einen Authentifizierungsanbieter, entscheiden Sie, wie Richtlinien Geräte erreichen, und planen Sie den Rollout196* [Richten Sie Claude Code für Ihre Organisation ein](/docs/de/admin-setup): Wählen Sie einen Authentifizierungsanbieter, entscheiden Sie, wie Richtlinien Geräte erreichen, und planen Sie den Rollout

197* [Server-verwaltete Einstellungen](/de/server-managed-settings): Liefern Sie verwaltete Richtlinien aus der Claude.ai-Admin-Konsole, damit Ingenieure sie nicht umgehen können, indem sie Repository-Dateien bearbeiten197* [Server-verwaltete Einstellungen](/docs/de/server-managed-settings): Liefern Sie verwaltete Richtlinien aus der Claude.ai-Admin-Konsole, damit Ingenieure sie nicht umgehen können, indem sie Repository-Dateien bearbeiten

198* [Überwachen Sie die Nutzung und überprüfen Sie die Aktivität](/de/monitoring-usage): Exportieren Sie OpenTelemetry-Metriken und überprüfen Sie, was Ihr Team ausführt198* [Überwachen Sie die Nutzung und überprüfen Sie die Aktivität](/docs/de/monitoring-usage): Exportieren Sie OpenTelemetry-Metriken und überprüfen Sie, was Ihr Team ausführt

199* [Netzwerkzugriffsanforderungen](/de/network-config#network-access-requirements): Die vollständige Domain-Allowlist für Proxys und Firewalls199* [Netzwerkzugriffsanforderungen](/docs/de/network-config#network-access-requirements): Die vollständige Domain-Allowlist für Proxys und Firewalls

200* [Telemetrie-Dienste und Opt-out](/de/data-usage#telemetry-services): Was Claude Code standardmäßig sendet und die Umgebungsvariablen, die es deaktivieren200* [Telemetrie-Dienste und Opt-out](/docs/de/data-usage#telemetry-services): Was Claude Code standardmäßig sendet und die Umgebungsvariablen, die es deaktivieren

201* [Erkunden Sie das `.claude`-Verzeichnis](/de/claude-directory): Was die Volume-Einbindung enthält, einschließlich Anmeldedaten, Einstellungen und Sitzungsverlauf201* [Erkunden Sie das `.claude`-Verzeichnis](/docs/de/claude-directory): Was die Volume-Einbindung enthält, einschließlich Anmeldedaten, Einstellungen und Sitzungsverlauf

202* [Sandbox-Umgebungen](/de/sandbox-environments): Vergleichen Sie Entwicklungscontainer mit der integrierten Bash-Sandbox, benutzerdefinierten Containern und VMs202* [Sandbox-Umgebungen](/docs/de/sandbox-environments): Vergleichen Sie Entwicklungscontainer mit der integrierten Bash-Sandbox, benutzerdefinierten Containern und VMs

203* [Sicherheitsmodell](/de/security): Wie Claude Codes Berechtigungssystem, Sandboxing und Prompt-Injection-Schutz zusammenpassen203* [Sicherheitsmodell](/docs/de/security): Wie Claude Codes Berechtigungssystem, Sandboxing und Prompt-Injection-Schutz zusammenpassen

204* [Berechtigungsmodi](/de/permission-modes): Die vollständige Spanne von Plan Mode bis Auto Mode bis Bypass, und wann man jeden verwendet204* [Berechtigungsmodi](/docs/de/permission-modes): Die vollständige Spanne von Plan Mode bis Auto Mode bis Bypass, und wann man jeden verwendet

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

4 

5# Andere LLM-Gateways

6 

7> Leiten Sie Claude Code über ein LLM-Gateway weiter, das Ihre Organisation bereits betreibt. Behandelt die Verbindung von Claude Code mit einem Gateway, die Bereitstellung für Ihre Organisation und was Claude Code an ein Gateway sendet.

8 

9Dieser Abschnitt behandelt die Verwendung eines Gateway-Produkts, das Ihre Organisation bereits betreibt, anstelle von [Claude Apps Gateway](/docs/de/claude-apps-gateway). Informationen dazu, was ein Gateway ist, wie es zwischen Claude Code und Ihrem Anbieter sitzt und wie Sie zwischen Claude Apps Gateway und einem anderen Produkt wählen, finden Sie in der [Gateway-Übersicht](/docs/de/gateways).

10 

11<Note>

12 * Wenn Sie ein Entwickler sind, der sich mit einem vorhandenen Gateway verbindet: [Verbinden Sie Claude Code mit Ihrem Gateway](/docs/de/llm-gateway-connect)

13 * Wenn Sie ein Administrator sind, der ein Gateway für Ihre Organisation bereitstellt: [Stellen Sie ein Gateway bereit und verteilen Sie es](/docs/de/llm-gateway-rollout)

14 * Wenn Sie ein Gateway-Produkt konfigurieren: die [Gateway-Protokoll-Referenz](/docs/de/llm-gateway-protocol)

15</Note>

16 

17Jedes Gateway, das ein [unterstütztes API-Format](/docs/de/llm-gateway-protocol#api-formats) bereitstellt, funktioniert. Anthropic befürwortet, wartet oder prüft keine Gateway-Produkte von Drittanbietern und unterstützt nicht das Routing von Claude Code zu Nicht-Claude-Modellen über ein Gateway. Stellen Sie das Gateway nach seiner eigenen Dokumentation bereit und schließen Sie dann die Claude Code-Seite mit den [Bereitstellungsschritten unten](#roll-out-a-gateway) ab.

18 

19<h2 id="what-a-gateway-provides">

20 Was ein Gateway bietet

21</h2>

22 

23Ein Gateway gibt Ihrer Organisation einen Ort zur Verwaltung von:

24 

25* **Anmeldedaten**: Der Anbieter-Schlüssel bleibt serverseitig; Entwickler halten stattdessen Gateway-Anmeldedaten

26* **Nutzungsverfolgung**: Attributieren Sie die Nutzung nach Entwickler oder Team, unabhängig davon, welcher Anbieter die Anfrage bedient

27* **Kostenkontrollen**: Erzwingen Sie Budgets und Ratenlimits an einem Ort

28* **Audit-Protokollierung**: Protokollieren Sie jede Modellanfrage zur Compliance

29* **Anbieter-Wechsel**: Ändern Sie den Anbieter in der Gateway-Konfiguration, ohne Entwicklermaschinen zu berühren

30 

31Alle diese außer dem Anbieter-Wechsel gelten, ob der Upstream die API von Anthropic oder ein [Cloud-Anbieter](/docs/de/third-party-integrations) ist. Der Anbieter-Wechsel ohne Neukonfiguration von Entwicklermaschinen hängt auch davon ab, dass das Gateway einen einzelnen [Anthropic-Format-Endpunkt](/docs/de/llm-gateway-protocol#api-formats) unabhängig vom Upstream bereitstellt; ein Gateway, das das eigene Format eines Anbieters bereitstellt, bindet die Client-Konfiguration an diesen Anbieter.

32 

33Der Kompromiss besteht darin, dass das Gateway zu einer Infrastruktur wird, die Ihre Organisation betreibt. Claude Code fügt mit jeder Version Funktionen hinzu, und ein Gateway, das diese nicht weiterleitet, bricht die entsprechenden Funktionen, daher muss das Gateway-Produkt aktualisiert werden, wenn sich Claude Code entwickelt. Die [Gateway-Protokoll-Referenz](/docs/de/llm-gateway-protocol) behandelt, was weitergeleitet werden soll.

34 

35<h2 id="roll-out-a-gateway">

36 Ein Gateway bereitstellen

37</h2>

38 

39Wenn Sie bereit sind, ein LLM-Gateway für Ihre Organisation bereitzustellen, ist die Abfolge gleich, welches Gateway-Produkt Sie auch wählen:

40 

411. Stellen Sie das Gateway bereit und geben Sie ihm Ihre Anbieter-Anmeldedaten, damit es die Anfragen authentifizieren kann, die es weiterleitet.

422. Geben Sie jedem Entwickler ein Gateway-Anmeldedaten aus, damit die Nutzung dem Entwickler zugeordnet wird und das Offboarding ein Anmeldedaten widerruft.

433. Verteilen Sie die Konfiguration über eine [verwaltete Einstellungsdatei](/docs/de/settings#settings-files) und Ihre Secrets-Tools, damit jede Maschine die Basis-URL und ein Anmeldedaten erhält. Wenn beide verteilt werden, konfigurieren Entwickler nichts. Wenn Sie keine Einstellungsverteilung haben, folgen Entwickler der [Verbindungsseite](/docs/de/llm-gateway-connect), um die Variablen selbst zu setzen.

444. Lassen Sie jeden Entwickler [die Konfiguration in Claude Code überprüfen](/docs/de/llm-gateway-connect#check-for-an-existing-configuration), damit Verteilungsprobleme auftauchen, bevor sie vom Gateway abhängig sind.

45 

46[Ein LLM-Gateway für Ihre Organisation bereitstellen](/docs/de/llm-gateway-rollout) führt jeden Schritt durch und zeigt die Konfigurationsdateien, die bei jedem verteilt werden sollen. Das Gateway ist ein Teil der Organisationseinrichtung; für Richtliniendurchsetzung, Nutzungssichtbarkeit und Datenbehandlungsentscheidungen siehe [Claude Code für Ihre Organisation einrichten](/docs/de/admin-setup).

47 

48<h2 id="subscriptions-and-gateways">

49 Abonnements und Gateways

50</h2>

51 

52Während eine [Gateway-Anmeldedaten-Variable](/docs/de/llm-gateway-connect#set-the-credential-variable) oder `apiKeyHelper` aktiv ist, wird das claude.ai-Abonnement eines Entwicklers nicht verwendet: Das Anmeldedaten ersetzt die Abonnement-Anmeldung für diese Sitzung, und die Nutzungslimits des Abonnements gelten nicht. Dieser Verkehr wird pro Token dem Besitzer des Anmeldedaten, das das Gateway weiterleitet, wie Ihr Anthropic Console-Konto der Organisation oder Ihr Bedrock-, Agent Platform- oder Foundry-Konto, wenn das Gateway dorthin leitet, in Rechnung gestellt.

53 

54[`ANTHROPIC_BASE_URL`](/docs/de/llm-gateway-connect#set-the-base-url-and-credential) ist die Variable, die Claude Code auf das Gateway verweist. Das Setzen nur dieser Variable ohne Gateway-Anmeldedaten ersetzt das Abonnement nicht. Anfragen werden immer noch über das Gateway geleitet, aber eine gespeicherte claude.ai-Anmeldung bleibt das aktive Anmeldedaten, daher gelten seine Nutzungslimits und Abrechnung. Gateways, die diesen Verkehr an Anthropic weitergeben, müssen die OAuth-Fähigkeit in `anthropic-beta` weiterleiten; siehe die [Request-Header-Referenz](/docs/de/llm-gateway-protocol#request-headers).

55 

56<h2 id="related-pages">

57 Verwandte Seiten

58</h2>

59 

60* [Gateway-Übersicht](/docs/de/gateways): wie ein Gateway funktioniert und wie Sie zwischen Claude Apps Gateway und einem anderen Produkt wählen

61* [Claude Apps Gateway](/docs/de/claude-apps-gateway): Anthropics selbstgehostetes Gateway mit SSO-Anmeldung und OTLP-Telemetrie

62* [Verbinden Sie Claude Code mit einem LLM-Gateway](/docs/de/llm-gateway-connect): Setzen Sie die Basis-URL und das Anmeldedaten auf Ihrer eigenen Maschine, mit Pro-Surface-Konfiguration und einer Fehlerbehebungstabelle

63* [Ein LLM-Gateway für Ihre Organisation bereitstellen](/docs/de/llm-gateway-rollout): Die Admin-Checkliste für die Bereitstellung eines Gateways, die Ausstellung von Entwickler-Anmeldedaten und die Verteilung verwalteter Einstellungen

64* [Gateway-Protokoll-Referenz](/docs/de/llm-gateway-protocol): was Claude Code an ein Gateway sendet, für Operatoren, die eines konfigurieren, mit Endpunkten, Headern zum Weiterleiten und Feature-Pass-Through

20 20 

21<img src="https://mintcdn.com/claude-code/VbDJw--l6T9a9Wvm/images/prompt-caching-prefix.svg?fit=max&auto=format&n=VbDJw--l6T9a9Wvm&q=85&s=f2e8f0b8298a50305fe428ca3f1d1594" className="dark:hidden" alt="Vier Turns werden als wachsende horizontale Balken angezeigt. Die Anfrage jedes Turns enthält alles aus dem vorherigen Turn plus den neuesten Austausch am Ende angehängt. Bei den Turns zwei und drei wird das unveränderte Präfix aus dem Cache gelesen und nur der neue Austausch verarbeitet. Bei Turn vier hat sich der System-Prompt geändert, daher stimmt das Präfix nicht mehr überein und die gesamte Anfrage wird neu verarbeitet und geschrieben." width="720" height="454" data-path="images/prompt-caching-prefix.svg" />21<img src="https://mintcdn.com/claude-code/VbDJw--l6T9a9Wvm/images/prompt-caching-prefix.svg?fit=max&auto=format&n=VbDJw--l6T9a9Wvm&q=85&s=f2e8f0b8298a50305fe428ca3f1d1594" className="dark:hidden" alt="Vier Turns werden als wachsende horizontale Balken angezeigt. Die Anfrage jedes Turns enthält alles aus dem vorherigen Turn plus den neuesten Austausch am Ende angehängt. Bei den Turns zwei und drei wird das unveränderte Präfix aus dem Cache gelesen und nur der neue Austausch verarbeitet. Bei Turn vier hat sich der System-Prompt geändert, daher stimmt das Präfix nicht mehr überein und die gesamte Anfrage wird neu verarbeitet und geschrieben." width="720" height="454" data-path="images/prompt-caching-prefix.svg" />

22 22 

23<img src="https://mintcdn.com/claude-code/VbDJw--l6T9a9Wvm/images/prompt-caching-prefix-dark.svg?fit=max&auto=format&n=VbDJw--l6T9a9Wvm&q=85&s=7434a04e08187edd26ec6c3dd332f624" className="hidden dark:block" alt="Vier Turns werden als wachsende horizontale Balken angezeigt. Die Anfrage jedes Turns enthält alles aus dem vorherigen Turn plus den neuesten Austausch am Ende angehängt. Bei den Turns zwei und drei wird das unveränderte Präfix aus dem Cache gelesen und nur der neue Austausch verarbeitet. Bei Turn vier hat sich der System-Prompt geändert, daher stimmt das Präfix nicht mehr überein und die gesamte Anfrage wird neu verarbeitet und geschrieben." width="720" height="454" data-path="images/prompt-caching-prefix-dark.svg" />23<img src="https://mintcdn.com/claude-code/_xqph1dUOslCOwsj/images/prompt-caching-prefix-dark.svg?fit=max&auto=format&n=_xqph1dUOslCOwsj&q=85&s=297dc1c639f0915cae858d0c4b6f3be5" className="hidden dark:block" alt="Vier Turns werden als wachsende horizontale Balken angezeigt. Die Anfrage jedes Turns enthält alles aus dem vorherigen Turn plus den neuesten Austausch am Ende angehängt. Bei den Turns zwei und drei wird das unveränderte Präfix aus dem Cache gelesen und nur der neue Austausch verarbeitet. Bei Turn vier hat sich der System-Prompt geändert, daher stimmt das Präfix nicht mehr überein und die gesamte Anfrage wird neu verarbeitet und geschrieben." width="720" height="454" data-path="images/prompt-caching-prefix-dark.svg" />

24 24 

25Um das Beste aus dem Präfix-Abgleich herauszuholen, ordnet Claude Code jede Anfrage so, dass Inhalte, die sich zwischen Turns selten ändern, zuerst kommen:25Um das Beste aus dem Präfix-Abgleich herauszuholen, ordnet Claude Code jede Anfrage so, dass Inhalte, die sich zwischen Turns selten ändern, zuerst kommen:

26 26 

32 32 

33Eine Änderung der Konversationsebene lässt den System-Prompt und Projektkontext gecacht. Eine Änderung des System-Prompts macht alles ungültig, da der gesamte spätere Inhalt nun hinter einem anderen Präfix sitzt. Die dritte Spalte gibt häufige Auslöser statt einer vollständigen Liste an, und die Abschnitte unten behandeln den vollständigen Satz, einschließlich Inhalte wie Ausgabestil, die am Anfang der Session festgelegt sind.33Eine Änderung der Konversationsebene lässt den System-Prompt und Projektkontext gecacht. Eine Änderung des System-Prompts macht alles ungültig, da der gesamte spätere Inhalt nun hinter einem anderen Präfix sitzt. Die dritte Spalte gibt häufige Auslöser statt einer vollständigen Liste an, und die Abschnitte unten behandeln den vollständigen Satz, einschließlich Inhalte wie Ausgabestil, die am Anfang der Session festgelegt sind.

34 34 

35Die Präfix-Abgleich-Regel erklärt die meisten Verhaltensweisen auf dieser Seite. [Plan Mode](/de/permission-modes#analyze-before-you-edit-with-plan-mode) und [Skill Loading](/de/skills) hängen beispielsweise ihre Anweisungen als Konversationsnachrichten an, daher bleibt das gecachte Präfix intakt.35Die Präfix-Abgleich-Regel erklärt die meisten Verhaltensweisen auf dieser Seite. [Plan Mode](/docs/de/permission-modes#analyze-before-you-edit-with-plan-mode) und [Skill Loading](/docs/de/skills) hängen beispielsweise ihre Anweisungen als Konversationsnachrichten an, daher bleibt das gecachte Präfix intakt.

36 36 

37Zwei Einstellungen sind überhaupt nicht Teil des Prompt-Textes, daher erscheinen sie nicht in der Ebenen-Tabelle, aber beide sind Teil des Cache-Schlüssels:37Zwei Einstellungen sind überhaupt nicht Teil des Prompt-Textes, daher erscheinen sie nicht in der Ebenen-Tabelle, aber beide sind Teil des Cache-Schlüssels:

38 38 

49 49 

50Caching findet server-seitig in der Infrastruktur statt, die Ihr Modell bedient. Wo das ist, hängt davon ab, wie Sie sich authentifizieren:50Caching findet server-seitig in der Infrastruktur statt, die Ihr Modell bedient. Wo das ist, hängt davon ab, wie Sie sich authentifizieren:

51 51 

52* **API-Schlüssel, Claude-Abonnement oder [Claude Platform on AWS](/de/claude-platform-on-aws)**: Der Cache lebt in Anthropics Infrastruktur, zugänglich über die [Claude API](https://platform.claude.com/docs)52* **API-Schlüssel, Claude-Abonnement oder [Claude Platform on AWS](/docs/de/claude-platform-on-aws)**: Der Cache lebt in Anthropics Infrastruktur, zugänglich über die [Claude API](https://platform.claude.com/docs)

53* **Amazon Bedrock oder Google Cloud's Agent Platform**: Der Cache lebt in der Serving-Infrastruktur Ihres Cloud-Providers53* **Amazon Bedrock oder Google Cloud's Agent Platform**: Der Cache lebt in der Serving-Infrastruktur Ihres Cloud-Providers

54* **Microsoft Foundry**: Anfragen werden an Anthropics Infrastruktur weitergeleitet54* **Microsoft Foundry**: Anfragen werden an Anthropics Infrastruktur weitergeleitet

55* **Benutzerdefinierte `ANTHROPIC_BASE_URL` oder [LLM Gateway](/de/llm-gateway)**: Der Cache lebt dort, wo Ihre Anfragen weitergeleitet werden, und ob Caching funktioniert, hängt vom Gateway ab55* **Benutzerdefinierte `ANTHROPIC_BASE_URL` oder [LLM Gateway](/docs/de/llm-gateway)**: Der Cache lebt dort, wo Ihre Anfragen weitergeleitet werden, und ob Caching funktioniert, hängt vom Gateway ab

56 56 

57Für das, was jeder Provider speichert und verarbeitet, siehe [Datennutzung](/de/data-usage). Wo immer der Cache lebt, Einträge verfallen nach einer Inaktivitätsperiode, und [Cache-Lebensdauer](#cache-lifetime) unten behandelt die TTL und wie Sie sie verlängern.57Für das, was jeder Provider speichert und verarbeitet, siehe [Datennutzung](/docs/de/data-usage). Wo immer der Cache lebt, Einträge verfallen nach einer Inaktivitätsperiode, und [Cache-Lebensdauer](#cache-lifetime) unten behandelt die TTL und wie Sie sie verlängern.

58 58 

59<h2 id="actions-that-invalidate-the-cache">59<h2 id="actions-that-invalidate-the-cache">

60 Aktionen, die den Cache ungültig machen60 Aktionen, die den Cache ungültig machen

75 Modelle wechseln75 Modelle wechseln

76</h3>76</h3>

77 77 

78Jedes Modell hat seinen eigenen Cache. Das Wechseln mit [`/model`](/de/model-config#setting-your-model) bedeutet, dass die nächste Anfrage die gesamte Konversationshistorie ohne Cache-Hits liest, obwohl der Inhalt identisch ist.78Jedes Modell hat seinen eigenen Cache. Das Wechseln mit [`/model`](/docs/de/model-config#setting-your-model) bedeutet, dass die nächste Anfrage die gesamte Konversationshistorie ohne Cache-Hits liest, obwohl der Inhalt identisch ist.

79 79 

80Die [`opusplan` Modelleinstellung](/de/model-config#opusplan-model-setting) wird zu Opus während Plan Mode und Sonnet während der Ausführung aufgelöst, daher ist jeder Plan-Mode-Toggle ein Modellwechsel und startet einen frischen Cache.80Die [`opusplan` Modelleinstellung](/docs/de/model-config#opusplan-model-setting) wird zu Opus während Plan Mode und Sonnet während der Ausführung aufgelöst, daher ist jeder Plan-Mode-Toggle ein Modellwechsel und startet einen frischen Cache.

81 81 

82[Automatisches Modell-Fallback](/de/model-config#automatic-model-fallback) auf Fable 5 ist auch ein Modellwechsel. Wenn ein Sicherheitsklassifizierer eine Anfrage kennzeichnet, führt Claude Code sie auf dem Standard-Opus-Modell erneut aus und die Session wird dort fortgesetzt.82[Automatisches Modell-Fallback](/docs/de/model-config#automatic-model-fallback) auf Fable 5 ist auch ein Modellwechsel. Wenn ein Sicherheitsklassifizierer eine Anfrage kennzeichnet, führt Claude Code sie auf dem Standard-Opus-Modell erneut aus und die Session wird dort fortgesetzt.

83 83 

84<h3 id="changing-effort-level">84<h3 id="changing-effort-level">

85 Anstrengungsstufe ändern85 Anstrengungsstufe ändern

86</h3>86</h3>

87 87 

88Der Cache wird nach [Anstrengungsstufe](/de/model-config#adjust-effort-level) sowie Modell verschlüsselt, daher bedeutet das Wechseln mit `/effort`, dass die nächste Anfrage die gesamte Konversationshistorie ohne Cache-Hits liest. Sobald eine Konversation gestartet wurde, zeigt Claude Code einen Bestätigungsdialog an, bevor eine Anstrengungsänderung angewendet wird, die den Cache ungültig machen würde. Eine Änderung, die sich auf die gleiche bereits gültige Stufe auflöst, z. B. das explizite Festlegen des Modellstandards, überspringt den Dialog und behält den Cache.88Der Cache wird nach [Anstrengungsstufe](/docs/de/model-config#adjust-effort-level) sowie Modell verschlüsselt, daher bedeutet das Wechseln mit `/effort`, dass die nächste Anfrage die gesamte Konversationshistorie ohne Cache-Hits liest. Sobald eine Konversation gestartet wurde, zeigt Claude Code einen Bestätigungsdialog an, bevor eine Anstrengungsänderung angewendet wird, die den Cache ungültig machen würde. Eine Änderung, die sich auf die gleiche bereits gültige Stufe auflöst, z. B. das explizite Festlegen des Modellstandards, überspringt den Dialog und behält den Cache.

89 89 

90<h3 id="turning-on-fast-mode">90<h3 id="turning-on-fast-mode">

91 Fast Mode aktivieren91 Fast Mode aktivieren

92</h3>92</h3>

93 93 

94Das Aktivieren von [Fast Mode](/de/fast-mode) fügt einen Request-Header hinzu, der Teil des Cache-Schlüssels ist, daher liest die nächste Anfrage die gesamte Konversationshistorie ohne Cache-Hits. Diese unkachedten Input-Token werden zu [Fast-Mode-Raten](/de/fast-mode#understand-the-cost-tradeoff) abgerechnet, weshalb das Aktivieren zu Beginn einer Session weniger kostet als das Aktivieren tief in einer langen Session. Das Aktivieren von Fast Mode von einem Nicht-Opus-Modell aus [wechselt auch Ihr Modell](#switching-models), was von selbst einen frischen Cache startet.94Das Aktivieren von [Fast Mode](/docs/de/fast-mode) fügt einen Request-Header hinzu, der Teil des Cache-Schlüssels ist, daher liest die nächste Anfrage die gesamte Konversationshistorie ohne Cache-Hits. Diese unkachedten Input-Token werden zu [Fast-Mode-Raten](/docs/de/fast-mode#understand-the-cost-tradeoff) abgerechnet, weshalb das Aktivieren zu Beginn einer Session weniger kostet als das Aktivieren tief in einer langen Session. Das Aktivieren von Fast Mode von einem Nicht-Opus-Modell aus [wechselt auch Ihr Modell](#switching-models), was von selbst einen frischen Cache startet.

95 95 

96Die Kosten fallen einmal pro Konversation an. Nach dem ersten Fast-Mode-Turn sendet Claude Code weiterhin den Header und variiert nur die Speed-Einstellung der Anfrage, die nicht Teil des Cache-Schlüssels ist. Das Ausschalten von Fast Mode, das [automatische Fallback auf Standardgeschwindigkeit](/de/fast-mode#handle-rate-limits) nach einem Rate Limit und das spätere Wiedereinschalten behalten den Cache. `/clear` und `/compact` setzen dies zurück, da sie den Cache an diesen Punkten ohnehin neu aufbauen.96Die Kosten fallen einmal pro Konversation an. Nach dem ersten Fast-Mode-Turn sendet Claude Code weiterhin den Header und variiert nur die Speed-Einstellung der Anfrage, die nicht Teil des Cache-Schlüssels ist. Das Ausschalten von Fast Mode, das [automatische Fallback auf Standardgeschwindigkeit](/docs/de/fast-mode#handle-rate-limits) nach einem Rate Limit und das spätere Wiedereinschalten behalten den Cache. `/clear` und `/compact` setzen dies zurück, da sie den Cache an diesen Punkten ohnehin neu aufbauen.

97 97 

98<h3 id="connecting-or-disconnecting-an-mcp-server">98<h3 id="connecting-or-disconnecting-an-mcp-server">

99 Verbinden oder Trennen eines MCP-Servers99 Verbinden oder Trennen eines MCP-Servers

100</h3>100</h3>

101 101 

102Tool-Definitionen sitzen in der System-Prompt-Ebene, daher wird der Cache ungültig, wenn sich die Menge der Tool-Definitionen in der Anfrage zwischen Turns ändert. Das Umschalten des [Advisor-Tools](/de/advisor) ist eine Ausnahme: Seine Definition sitzt nach dem Cache-Breakpoint, daher behält das Aktivieren oder Deaktivieren von `/advisor` das gecachte Präfix intakt. Ob eine [MCP-Server](/de/mcp)-Änderung dies bewirkt, hängt davon ab, ob ihre Tools durch [Tool-Suche](/de/mcp#scale-with-mcp-tool-search) aufgeschoben werden oder in das Präfix geladen werden:102Tool-Definitionen sitzen in der System-Prompt-Ebene, daher wird der Cache ungültig, wenn sich die Menge der Tool-Definitionen in der Anfrage zwischen Turns ändert. Das Umschalten des [Advisor-Tools](/docs/de/advisor) ist eine Ausnahme: Seine Definition sitzt nach dem Cache-Breakpoint, daher behält das Aktivieren oder Deaktivieren von `/advisor` das gecachte Präfix intakt. Ob eine [MCP-Server](/docs/de/mcp)-Änderung dies bewirkt, hängt davon ab, ob ihre Tools durch [Tool-Suche](/docs/de/mcp#scale-with-mcp-tool-search) aufgeschoben werden oder in das Präfix geladen werden:

103 103 

104* **Aufgeschobene Tools**, die Standardeinstellung auf unterstützten Modellen: Ein Server, der sich verbindet, trennt oder seine Tool-Liste ändert, hängt nur neue Inhalte an und stört nichts, das bereits gecacht ist.104* **Aufgeschobene Tools**, die Standardeinstellung auf unterstützten Modellen: Ein Server, der sich verbindet, trennt oder seine Tool-Liste ändert, hängt nur neue Inhalte an und stört nichts, das bereits gecacht ist.

105* **Tools, die in das Präfix geladen werden**: Jede Änderung daran macht den Cache ungültig. Dies geschieht, wenn [Tool-Suche nicht verfügbar oder deaktiviert ist](/de/mcp#configure-tool-search), z. B. auf Google Cloud's Agent Platform oder mit einem benutzerdefinierten `ANTHROPIC_BASE_URL`-Gateway. Es geschieht auch für einen Server oder ein Tool, das als [`alwaysLoad`](/de/mcp#exempt-a-server-from-deferral) markiert ist, und für Definitionen, die von [schwellenwertbasiertem Laden](/de/mcp#configure-tool-search) im Voraus beibehalten werden.105* **Tools, die in das Präfix geladen werden**: Jede Änderung daran macht den Cache ungültig. Dies geschieht, wenn [Tool-Suche nicht verfügbar oder deaktiviert ist](/docs/de/mcp#configure-tool-search), z. B. auf Google Cloud's Agent Platform oder mit einem benutzerdefinierten `ANTHROPIC_BASE_URL`-Gateway. Es geschieht auch für einen Server oder ein Tool, das als [`alwaysLoad`](/docs/de/mcp#exempt-a-server-from-deferral) markiert ist, und für Definitionen, die von [schwellenwertbasiertem Laden](/docs/de/mcp#configure-tool-search) im Voraus beibehalten werden.

106 106 

107Wenn Tools in das Präfix geladen werden, ist die häufigste Ursache einer Ungültigmachung ein Server, der sich mid-session verbindet oder trennt, was ohne Ihre Aktion geschehen kann: Ein Stdio-Server-Prozess beendet sich, eine HTTP-Session läuft ab, oder ein Server [verbindet sich automatisch nach einem vorübergehenden Fehler wieder](/de/mcp#automatic-reconnection). Ein verbundener Server kann auch ein [dynamisches Tool-Update](/de/mcp#dynamic-tool-updates) pushen, das seine Tool-Liste ändert.107Wenn Tools in das Präfix geladen werden, ist die häufigste Ursache einer Ungültigmachung ein Server, der sich mid-session verbindet oder trennt, was ohne Ihre Aktion geschehen kann: Ein Stdio-Server-Prozess beendet sich, eine HTTP-Session läuft ab, oder ein Server [verbindet sich automatisch nach einem vorübergehenden Fehler wieder](/docs/de/mcp#automatic-reconnection). Ein verbundener Server kann auch ein [dynamisches Tool-Update](/docs/de/mcp#dynamic-tool-updates) pushen, das seine Tool-Liste ändert.

108 108 

109Das Bearbeiten Ihrer MCP-Konfiguration ändert den Cache nicht von selbst. Die neue Konfiguration wird erst nach einem Neustart wirksam, wenn sich der Server verbindet oder trennt.109Das Bearbeiten Ihrer MCP-Konfiguration ändert den Cache nicht von selbst. Die neue Konfiguration wird erst nach einem Neustart wirksam, wenn sich der Server verbindet oder trennt.

110 110 

112 Ein Plugin aktivieren oder deaktivieren112 Ein Plugin aktivieren oder deaktivieren

113</h3>113</h3>

114 114 

115[Plugins](/de/plugins) bündeln mehrere Komponententypen, und die Kosten einer Änderung hängen davon ab, welche Komponenten das Plugin bereitstellt. Skills, Commands, Agents, Hooks, LSP-Server, Monitore und Themes machen den Cache niemals ungültig: Alles, das sie zur Anfrage hinzufügen, wird nach der vorhandenen Konversation angehängt, daher zahlt die nächste Anfrage für den neuen Inhalt, liest aber alles davor immer noch aus dem Cache.115[Plugins](/docs/de/plugins) bündeln mehrere Komponententypen, und die Kosten einer Änderung hängen davon ab, welche Komponenten das Plugin bereitstellt. Skills, Commands, Agents, Hooks, LSP-Server, Monitore und Themes machen den Cache niemals ungültig: Alles, das sie zur Anfrage hinzufügen, wird nach der vorhandenen Konversation angehängt, daher zahlt die nächste Anfrage für den neuen Inhalt, liest aber alles davor immer noch aus dem Cache.

116 116 

117Die Ausnahme ist ein Plugin, das [MCP-Server](/de/plugins-reference#mcp-servers) bereitstellt. Das Aktivieren oder Deaktivieren eines solchen folgt den gleichen Regeln wie [Verbinden oder Trennen eines MCP-Servers](#connecting-or-disconnecting-an-mcp-server): Der Cache bleibt erhalten, wenn die Tools des Servers aufgeschoben werden, und die nächste Anfrage liest die gesamte Konversation neu, wenn sie in das Präfix geladen werden.117Die Ausnahme ist ein Plugin, das [MCP-Server](/docs/de/plugins-reference#mcp-servers) bereitstellt. Das Aktivieren oder Deaktivieren eines solchen folgt den gleichen Regeln wie [Verbinden oder Trennen eines MCP-Servers](#connecting-or-disconnecting-an-mcp-server): Der Cache bleibt erhalten, wenn die Tools des Servers aufgeschoben werden, und die nächste Anfrage liest die gesamte Konversation neu, wenn sie in das Präfix geladen werden.

118 118 

119Plugin-Änderungen werden angewendet, wenn Sie [`/reload-plugins`](/de/discover-plugins#apply-plugin-changes-without-restarting) ausführen oder eine neue Session starten. Die Kosten, ob angehängte Ankündigungen oder ein vollständiges Neueinlesen, zeigen sich beim ersten Turn nach dem Neustart, nicht wenn Sie `/plugin install`, `/plugin enable` oder `/plugin disable` ausführen. {/* min-version: 2.1.163 */}Ab v2.1.163 zeigt `/reload-plugins` eine Warnung an und wendet das Neustart nicht an, wenn ein Neustart das vollständige Neueinlesen auslösen würde. Übergeben Sie `--force`, um es trotzdem anzuwenden.119Plugin-Änderungen werden angewendet, wenn Sie [`/reload-plugins`](/docs/de/discover-plugins#apply-plugin-changes-without-restarting) ausführen oder eine neue Session starten. Die Kosten, ob angehängte Ankündigungen oder ein vollständiges Neueinlesen, zeigen sich beim ersten Turn nach dem Neustart, nicht wenn Sie `/plugin install`, `/plugin enable` oder `/plugin disable` ausführen. {/* min-version: 2.1.163 */}Ab v2.1.163 zeigt `/reload-plugins` eine Warnung an und wendet das Neustart nicht an, wenn ein Neustart das vollständige Neueinlesen auslösen würde. Übergeben Sie `--force`, um es trotzdem anzuwenden.

120 120 

121Das Deaktivieren eines Plugins, das Sie früher in der Session aktiviert haben, stellt die vorherige Anfragefom wieder her. Wenn dieses Präfix noch innerhalb seiner [Cache-Lebensdauer](#cache-lifetime) liegt, liest die nächste Anfrage stattdessen den älteren Cache-Eintrag, anstatt ihn neu zu erstellen.121Das Deaktivieren eines Plugins, das Sie früher in der Session aktiviert haben, stellt die vorherige Anfragefom wieder her. Wenn dieses Präfix noch innerhalb seiner [Cache-Lebensdauer](#cache-lifetime) liegt, liest die nächste Anfrage stattdessen den älteren Cache-Eintrag, anstatt ihn neu zu erstellen.

122 122 

124 Ein ganzes Tool ablehnen124 Ein ganzes Tool ablehnen

125</h3>125</h3>

126 126 

127Das Hinzufügen eines bloßen Tool-Namens wie `Bash` oder `WebFetch` als [Ablehnungsregel](/de/permissions#manage-permissions) entfernt dieses Tool vollständig aus Claudes Kontext. Tool-Definitionen werden in die System-Prompt-Ebene geladen, daher macht das Hinzufügen oder Entfernen einer dieser Regeln mid-session den Cache ungültig. Die Änderung wird beim nächsten Turn wirksam, egal ob Sie sie über `/permissions` hinzufügen oder durch [direktes Bearbeiten einer Einstellungsdatei](/de/settings#when-edits-take-effect).127Das Hinzufügen eines bloßen Tool-Namens wie `Bash` oder `WebFetch` als [Ablehnungsregel](/docs/de/permissions#manage-permissions) entfernt dieses Tool vollständig aus Claudes Kontext. Tool-Definitionen werden in die System-Prompt-Ebene geladen, daher macht das Hinzufügen oder Entfernen einer dieser Regeln mid-session den Cache ungültig. Die Änderung wird beim nächsten Turn wirksam, egal ob Sie sie über `/permissions` hinzufügen oder durch [direktes Bearbeiten einer Einstellungsdatei](/docs/de/settings#when-edits-take-effect).

128 128 

129Nur eine Ablehnungsregel, die in der Tool-Name-Position passt, hat diese Auswirkung: ein bloßer Tool-Name, die äquivalente `Bash(*)` Form oder ein [Tool-Name-Glob](/de/permissions#tool-name-wildcards) wie `"*"`. Ein Glob, der nur MCP-Tools passt, z. B. `"mcp__*"`, entfernt diese Tools auf die gleiche Weise, behält aber den Cache intakt, wenn die gefundenen Tools [aufgeschoben](#connecting-or-disconnecting-an-mcp-server) sind, die Standardeinstellung, da aufgeschobene Definitionen nie im gecachten Präfix waren. Scoped Ablehnungsregeln wie `Bash(rm *)` und alle Allow- und Ask-Regeln ändern nicht, welche Tools Claude sieht. Claude Code prüft sie, wenn Claude einen Aufruf versucht, wobei das Präfix intakt bleibt.129Nur eine Ablehnungsregel, die in der Tool-Name-Position passt, hat diese Auswirkung: ein bloßer Tool-Name, die äquivalente `Bash(*)` Form oder ein [Tool-Name-Glob](/docs/de/permissions#tool-name-wildcards) wie `"*"`. Ein Glob, der nur MCP-Tools passt, z. B. `"mcp__*"`, entfernt diese Tools auf die gleiche Weise, behält aber den Cache intakt, wenn die gefundenen Tools [aufgeschoben](#connecting-or-disconnecting-an-mcp-server) sind, die Standardeinstellung, da aufgeschobene Definitionen nie im gecachten Präfix waren. Scoped Ablehnungsregeln wie `Bash(rm *)` und alle Allow- und Ask-Regeln ändern nicht, welche Tools Claude sieht. Claude Code prüft sie, wenn Claude einen Aufruf versucht, wobei das Präfix intakt bleibt.

130 130 

131<h3 id="compacting-the-conversation">131<h3 id="compacting-the-conversation">

132 Konversation komprimieren132 Konversation komprimieren

133</h3>133</h3>

134 134 

135[Komprimierung](/de/context-window#what-survives-compaction) ersetzt Ihre Nachrichtenhistorie durch eine Zusammenfassung. Dies macht absichtlich die Konversationsebene ungültig, da die nächste Anfrage eine neue, kürzere Historie hat, die kein Präfix mit der alten teilt. Claude Code nutzt die System-Prompt-Ebene wieder und lädt den Projektkontext von der Festplatte neu, was nur Cache-Hits, wenn CLAUDE.md und Memory seit dem Session-Start unverändert sind.135[Komprimierung](/docs/de/context-window#what-survives-compaction) ersetzt Ihre Nachrichtenhistorie durch eine Zusammenfassung. Dies macht absichtlich die Konversationsebene ungültig, da die nächste Anfrage eine neue, kürzere Historie hat, die kein Präfix mit der alten teilt. Claude Code nutzt die System-Prompt-Ebene wieder und lädt den Projektkontext von der Festplatte neu, was nur Cache-Hits, wenn CLAUDE.md und Memory seit dem Session-Start unverändert sind.

136 136 

137Um die Zusammenfassung zu erstellen, sendet Claude Code eine einmalige Anfrage mit demselben System-Prompt, Tools und History wie Ihre Konversation, plus eine Zusammenfassungsanweisung, die als letzte Benutzernachricht angehängt wird. Da sie Ihr Präfix teilt, liest diese Anfrage den vorhandenen Cache, anstatt die vollständige Historie neu zu verarbeiten. Der größte Teil der Komprimierungszeit geht in die Generierung der Zusammenfassung, nicht in einen Cache-Miss. Der Turn, der folgt, baut den Konversations-Cache nur für die viel kürzere Zusammenfassung neu auf, daher ist der Post-Komprimierungs-Turn nicht der langsame Teil.137Um die Zusammenfassung zu erstellen, sendet Claude Code eine einmalige Anfrage mit demselben System-Prompt, Tools und History wie Ihre Konversation, plus eine Zusammenfassungsanweisung, die als letzte Benutzernachricht angehängt wird. Da sie Ihr Präfix teilt, liest diese Anfrage den vorhandenen Cache, anstatt die vollständige Historie neu zu verarbeiten. Der größte Teil der Komprimierungszeit geht in die Generierung der Zusammenfassung, nicht in einen Cache-Miss. Der Turn, der folgt, baut den Konversations-Cache nur für die viel kürzere Zusammenfassung neu auf, daher ist der Post-Komprimierungs-Turn nicht der langsame Teil.

138 138 

144 Claude Code aktualisieren144 Claude Code aktualisieren

145</h3>145</h3>

146 146 

147Eine neue Claude Code-Version aktualisiert typischerweise den System-Prompt oder Tool-Definitionen, daher baut die erste Anfrage nach einem Upgrade den Cache von oben auf. [Auto-Update](/de/setup#auto-updates) lädt neue Versionen im Hintergrund herunter, wendet sie aber beim nächsten Start an, nie mid-session, daher sehen Sie dies als einen unkachedten ersten Turn nach dem Neustart statt als Überraschung während einer Session. Setzen Sie `DISABLE_AUTOUPDATER=1`, um zu kontrollieren, wann Upgrades angewendet werden.147Eine neue Claude Code-Version aktualisiert typischerweise den System-Prompt oder Tool-Definitionen, daher baut die erste Anfrage nach einem Upgrade den Cache von oben auf. [Auto-Update](/docs/de/setup#auto-updates) lädt neue Versionen im Hintergrund herunter, wendet sie aber beim nächsten Start an, nie mid-session, daher sehen Sie dies als einen unkachedten ersten Turn nach dem Neustart statt als Überraschung während einer Session. Setzen Sie `DISABLE_AUTOUPDATER=1`, um zu kontrollieren, wann Upgrades angewendet werden.

148 148 

149<Note>149<Note>

150 [Eine Session nach einem Upgrade fortsetzen](/de/sessions#resume-a-session) verarbeitet die gesamte Konversationshistorie ohne Cache-Hits neu, da die Historie nun hinter einem anderen System-Prompt sitzt. Die Kosten skalieren mit der Länge der fortgesetzten Konversation, daher kann der erste Turn zurück in eine lange Session die teuerste Anfrage sein, die Sie senden.150 [Eine Session nach einem Upgrade fortsetzen](/docs/de/sessions#resume-a-session) verarbeitet die gesamte Konversationshistorie ohne Cache-Hits neu, da die Historie nun hinter einem anderen System-Prompt sitzt. Die Kosten skalieren mit der Länge der fortgesetzten Konversation, daher kann der erste Turn zurück in eine lange Session die teuerste Anfrage sein, die Sie senden.

151</Note>151</Note>

152 152 

153<h2 id="actions-that-keep-the-cache">153<h2 id="actions-that-keep-the-cache">

177 177 

178Ihre Projekt-Root- und Benutzer-Level-CLAUDE.md-Dateien werden einmal am Session-Start gelesen und im Speicher gehalten. Das Bearbeiten von ihnen mid-session macht den Cache nicht ungültig, aber die Bearbeitung wird auch nicht angewendet. Claude arbeitet weiterhin mit der Version, die am Session-Start geladen wurde. Der neue Inhalt wird beim nächsten `/clear`, `/compact` oder Neustart geladen.178Ihre Projekt-Root- und Benutzer-Level-CLAUDE.md-Dateien werden einmal am Session-Start gelesen und im Speicher gehalten. Das Bearbeiten von ihnen mid-session macht den Cache nicht ungültig, aber die Bearbeitung wird auch nicht angewendet. Claude arbeitet weiterhin mit der Version, die am Session-Start geladen wurde. Der neue Inhalt wird beim nächsten `/clear`, `/compact` oder Neustart geladen.

179 179 

180[Verschachtelte CLAUDE.md-Dateien in Unterverzeichnissen](/de/memory) und [Rules mit `paths:` Frontmatter](/de/memory#path-specific-rules) werden später geladen, wenn Claude zum ersten Mal eine passende Datei liest. Das Bearbeiten einer vor dem Laden hat Auswirkungen. Nach dem Laden ist der Inhalt Teil der Konversationshistorie, daher ändert eine mid-session-Bearbeitung ihn nicht rückwirkend.180[Verschachtelte CLAUDE.md-Dateien in Unterverzeichnissen](/docs/de/memory) und [Rules mit `paths:` Frontmatter](/docs/de/memory#path-specific-rules) werden später geladen, wenn Claude zum ersten Mal eine passende Datei liest. Das Bearbeiten einer vor dem Laden hat Auswirkungen. Nach dem Laden ist der Inhalt Teil der Konversationshistorie, daher ändert eine mid-session-Bearbeitung ihn nicht rückwirkend.

181 181 

182<h3 id="changing-output-style">182<h3 id="changing-output-style">

183 Ausgabestil ändern183 Ausgabestil ändern

184</h3>184</h3>

185 185 

186[Ausgabestil](/de/output-styles) ist Teil des System-Prompts, den Claude Code einmal am Session-Start liest. Das Ändern über `/config` oder die `outputStyle`-Einstellung mid-session macht den Cache nicht ungültig, aber die Änderung wird auch nicht angewendet. Claude verwendet weiterhin den Stil, der am Session-Start geladen wurde. Der neue Stil wird beim nächsten `/clear` oder Neustart geladen.186[Ausgabestil](/docs/de/output-styles) ist Teil des System-Prompts, den Claude Code einmal am Session-Start liest. Das Ändern über `/config` oder die `outputStyle`-Einstellung mid-session macht den Cache nicht ungültig, aber die Änderung wird auch nicht angewendet. Claude verwendet weiterhin den Stil, der am Session-Start geladen wurde. Der neue Stil wird beim nächsten `/clear` oder Neustart geladen.

187 187 

188<h3 id="changing-permission-mode">188<h3 id="changing-permission-mode">

189 Permission Mode ändern189 Permission Mode ändern

190</h3>190</h3>

191 191 

192Das Wechseln zwischen [Permission Modes](/de/permission-modes), z. B. von Standard zu Accept Edits, ändert den System-Prompt oder Tool-Definitionen nicht, daher sind Mode-Wechsel Cache-sicher. Die Ausnahme ist Plan Mode mit der [`opusplan`](/de/model-config#opusplan-model-setting) Modelleinstellung, die das Modell zwischen Opus und Sonnet wechselt, wenn Sie Plan Mode betreten oder verlassen. Das macht den Mode-Toggle zu einem [Modellwechsel](#switching-models).192Das Wechseln zwischen [Permission Modes](/docs/de/permission-modes), z. B. von Standard zu Accept Edits, ändert den System-Prompt oder Tool-Definitionen nicht, daher sind Mode-Wechsel Cache-sicher. Die Ausnahme ist Plan Mode mit der [`opusplan`](/docs/de/model-config#opusplan-model-setting) Modelleinstellung, die das Modell zwischen Opus und Sonnet wechselt, wenn Sie Plan Mode betreten oder verlassen. Das macht den Mode-Toggle zu einem [Modellwechsel](#switching-models).

193 193 

194<h3 id="invoking-skills-and-commands">194<h3 id="invoking-skills-and-commands">

195 Skills und Commands aufrufen195 Skills und Commands aufrufen

196</h3>196</h3>

197 197 

198[Skills](/de/skills) und [Commands](/de/commands) injizieren ihre Anweisungen als Benutzernachrichten am Punkt der Aufrufe. Nichts früher in der Konversation ändert sich.198[Skills](/docs/de/skills) und [Commands](/docs/de/commands) injizieren ihre Anweisungen als Benutzernachrichten am Punkt der Aufrufe. Nichts früher in der Konversation ändert sich.

199 199 

200<h3 id="running-/recap">200<h3 id="running-/recap">

201 Ausführen von `/recap`201 Ausführen von `/recap`

202</h3>202</h3>

203 203 

204[`/recap`](/de/interactive-mode#session-recap) generiert eine Zusammenfassung zur Anzeige in Ihrem Terminal. Im Gegensatz zu `/compact` hängt es die Zusammenfassung als Befehlsausgabe an, anstatt Ihre Nachrichtenhistorie zu ersetzen, daher bleibt das gecachte Präfix intakt.204[`/recap`](/docs/de/interactive-mode#session-recap) generiert eine Zusammenfassung zur Anzeige in Ihrem Terminal. Im Gegensatz zu `/compact` hängt es die Zusammenfassung als Befehlsausgabe an, anstatt Ihre Nachrichtenhistorie zu ersetzen, daher bleibt das gecachte Präfix intakt.

205 205 

206<h3 id="rewinding-the-conversation">206<h3 id="rewinding-the-conversation">

207 Konversation zurückspulen207 Konversation zurückspulen

208</h3>208</h3>

209 209 

210[`/rewind`](/de/checkpointing) schneidet Ihre Konversation auf einen früheren Turn zurück. Die verbleibende Historie ist derselbe Inhalt, aus dem der Cache zu diesem Punkt gebaut wurde, und die System-Prompt- und Projektkontext-Ebenen sind unverändert, daher trifft die nächste Anfrage den früheren Cache-Eintrag. Jeder Turn seitdem hat dieses Präfix gelesen, das den Eintrag warm hielt, auch wenn der ursprüngliche Turn länger her war als die TTL.210[`/rewind`](/docs/de/checkpointing) schneidet Ihre Konversation auf einen früheren Turn zurück. Die verbleibende Historie ist derselbe Inhalt, aus dem der Cache zu diesem Punkt gebaut wurde, und die System-Prompt- und Projektkontext-Ebenen sind unverändert, daher trifft die nächste Anfrage den früheren Cache-Eintrag. Jeder Turn seitdem hat dieses Präfix gelesen, das den Eintrag warm hielt, auch wenn der ursprüngliche Turn länger her war als die TTL.

211 211 

212Das Wiederherstellen von Datei-Checkpoints zusammen mit der Konversation hat keine separate Auswirkung auf den Cache. Dateiinhalte treten in den Kontext nur ein, wenn Claude sie liest, dasselbe wie [Dateien in Ihrem Repository bearbeiten](#editing-files-in-your-repository).212Das Wiederherstellen von Datei-Checkpoints zusammen mit der Konversation hat keine separate Auswirkung auf den Cache. Dateiinhalte treten in den Kontext nur ein, wenn Claude sie liest, dasselbe wie [Dateien in Ihrem Repository bearbeiten](#editing-files-in-your-repository).

213 213 

239 TTL überschreiben239 TTL überschreiben

240</h3>240</h3>

241 241 

242Setzen Sie `FORCE_PROMPT_CACHING_5M=1`, um die fünf-Minuten-TTL unabhängig von der Authentifizierung zu erzwingen. Dies ist nützlich, wenn Sie das Cache-Verhalten debuggen, die beiden TTLs vergleichen oder ein in [verwalteten Einstellungen](/de/settings#settings-files) gesetztes `ENABLE_PROMPT_CACHING_1H` überschreiben.242Setzen Sie `FORCE_PROMPT_CACHING_5M=1`, um die fünf-Minuten-TTL unabhängig von der Authentifizierung zu erzwingen. Dies ist nützlich, wenn Sie das Cache-Verhalten debuggen, die beiden TTLs vergleichen oder ein in [verwalteten Einstellungen](/docs/de/settings#settings-files) gesetztes `ENABLE_PROMPT_CACHING_1H` überschreiben.

243 243 

244<h2 id="cache-scope">244<h2 id="cache-scope">

245 Cache-Umfang245 Cache-Umfang

249 249 

250Sessions, die Sie parallel im selben Verzeichnis ausführen, bauen passende Präfixe auf und lesen den Cache des anderen. Sequenzielle Sessions teilen das Präfix nur, wenn der Git-Status-Snapshot beim Start übereinstimmt, da der System-Prompt auch Branch und aktuelle Commits erfasst.250Sessions, die Sie parallel im selben Verzeichnis ausführen, bauen passende Präfixe auf und lesen den Cache des anderen. Sequenzielle Sessions teilen das Präfix nur, wenn der Git-Status-Snapshot beim Start übereinstimmt, da der System-Prompt auch Branch und aktuelle Commits erfasst.

251 251 

252Der zugrunde liegende API-Cache ist breiter. Caches sind zwischen Organisationen isoliert, und bei einigen Providern [zwischen Workspaces innerhalb einer Organisation](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#cache-storage-and-sharing). Innerhalb dieser Grenzen lesen zwei Anfragen mit demselben Modell und Präfix denselben Cache. Für Agent SDK-Aufrufer, die Flotten automatisierter Prozesse ausführen, siehe [Prompt Caching über Benutzer und Maschinen verbessern](/de/agent-sdk/modifying-system-prompts#improve-prompt-caching-across-users-and-machines), um die Pro-Maschinen-Abschnitte des System-Prompts zu unterdrücken und den Cache über Maschinen zu teilen.252Der zugrunde liegende API-Cache ist breiter. Caches sind zwischen Organisationen isoliert, und bei einigen Providern [zwischen Workspaces innerhalb einer Organisation](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#cache-storage-and-sharing). Innerhalb dieser Grenzen lesen zwei Anfragen mit demselben Modell und Präfix denselben Cache. Für Agent SDK-Aufrufer, die Flotten automatisierter Prozesse ausführen, siehe [Prompt Caching über Benutzer und Maschinen verbessern](/docs/de/agent-sdk/modifying-system-prompts#improve-prompt-caching-across-users-and-machines), um die Pro-Maschinen-Abschnitte des System-Prompts zu unterdrücken und den Cache über Maschinen zu teilen.

253 253 

254<h2 id="check-cache-performance">254<h2 id="check-cache-performance">

255 Cache-Leistung überprüfen255 Cache-Leistung überprüfen

256</h2>256</h2>

257 257 

258Cache-Leistung zeigt sich als zwei Token-Zählungen, die die API bei jeder Antwort meldet. Der direkteste Weg, sie live zu beobachten, ist ein [Statusline-Skript](/de/statusline), das das `current_usage`-Objekt liest:258Cache-Leistung zeigt sich als zwei Token-Zählungen, die die API bei jeder Antwort meldet. Der direkteste Weg, sie live zu beobachten, ist ein [Statusline-Skript](/docs/de/statusline), das das `current_usage`-Objekt liest:

259 259 

260| Feld | Bedeutung |260| Feld | Bedeutung |

261| ----------------------------- | ----------------------------------------------------------------------------------------------------------------- |261| ----------------------------- | ----------------------------------------------------------------------------------------------------------------- |

264 264 

265Ein hohes Lese-zu-Erstellungs-Verhältnis bedeutet, dass Caching gut funktioniert. Wenn die Erstellung Turn für Turn hoch bleibt, ändert sich etwas in Ihrem Präfix. Der Abschnitt [Aktionen, die den Cache ungültig machen](#actions-that-invalidate-the-cache) listet die üblichen Ursachen auf.265Ein hohes Lese-zu-Erstellungs-Verhältnis bedeutet, dass Caching gut funktioniert. Wenn die Erstellung Turn für Turn hoch bleibt, ändert sich etwas in Ihrem Präfix. Der Abschnitt [Aktionen, die den Cache ungültig machen](#actions-that-invalidate-the-cache) listet die üblichen Ursachen auf.

266 266 

267Für Sichtbarkeit über eine Organisation hinweg meldet der OpenTelemetry-Exporter Cache-Lese- und Erstellungs-Tokens pro Benutzer und Session. Siehe [Nutzung überwachen](/de/monitoring-usage) für die Metrik- und Event-Attribut-Referenz.267Für Sichtbarkeit über eine Organisation hinweg meldet der OpenTelemetry-Exporter Cache-Lese- und Erstellungs-Tokens pro Benutzer und Session. Siehe [Nutzung überwachen](/docs/de/monitoring-usage) für die Metrik- und Event-Attribut-Referenz.

268 268 

269<h2 id="subagents-and-the-cache">269<h2 id="subagents-and-the-cache">

270 Subagents und der Cache270 Subagents und der Cache

271</h2>271</h2>

272 272 

273Ein [Subagent](/de/sub-agents) startet seine eigene Konversation mit seinem eigenen System-Prompt und Tool-Set, getrennt vom Parent. Er baut seinen eigenen Cache auf, beginnend ohne Cache-Hits bei seinem ersten Aufruf und wärmend über seine eigenen Turns. Subagents verwenden die fünf-Minuten-TTL auch bei einem Abonnement, da die automatische eine-Stunden-TTL für die Hauptkonversation gilt.273Ein [Subagent](/docs/de/sub-agents) startet seine eigene Konversation mit seinem eigenen System-Prompt und Tool-Set, getrennt vom Parent. Er baut seinen eigenen Cache auf, beginnend ohne Cache-Hits bei seinem ersten Aufruf und wärmend über seine eigenen Turns. Subagents verwenden die fünf-Minuten-TTL auch bei einem Abonnement, da die automatische eine-Stunden-TTL für die Hauptkonversation gilt.

274 274 

275Der Cache des Parents ist unberührt. Von der Parent-Seite hängen der Aufruf und das Ergebnis des Subagents an die Konversation an, wobei das Parent-Präfix intakt bleibt.275Der Cache des Parents ist unberührt. Von der Parent-Seite hängen der Aufruf und das Ergebnis des Subagents an die Konversation an, wobei das Parent-Präfix intakt bleibt.

276 276 

277Ein [Fork](/de/sub-agents#fork-the-current-conversation) erbt dagegen den System-Prompt, die Tools und die Konversationshistorie des Parents genau, daher liest seine erste Anfrage den Cache des Parents. Der Komprimierungs-Zusammenfassungsaufruf, der in [Konversation komprimieren](#compacting-the-conversation) beschrieben wird, verwendet denselben Präfix-Sharing-Ansatz.277Ein [Fork](/docs/de/sub-agents#fork-the-current-conversation) erbt dagegen den System-Prompt, die Tools und die Konversationshistorie des Parents genau, daher liest seine erste Anfrage den Cache des Parents. Der Komprimierungs-Zusammenfassungsaufruf, der in [Konversation komprimieren](#compacting-the-conversation) beschrieben wird, verwendet denselben Präfix-Sharing-Ansatz.

278 278 

279<h2 id="disable-prompt-caching">279<h2 id="disable-prompt-caching">

280 Prompt Caching deaktivieren280 Prompt Caching deaktivieren

290| `DISABLE_PROMPT_CACHING_OPUS` | Nur für Opus deaktivieren |290| `DISABLE_PROMPT_CACHING_OPUS` | Nur für Opus deaktivieren |

291| `DISABLE_PROMPT_CACHING_FABLE` | Nur für Fable deaktivieren |291| `DISABLE_PROMPT_CACHING_FABLE` | Nur für Fable deaktivieren |

292 292 

293Um die Caching-Richtlinie über eine Organisation hinweg festzulegen, setzen Sie eine dieser oder die [TTL-Variablen](#cache-lifetime) in den `env`-Block von [verwalteten Einstellungen](/de/settings#settings-files). Für normale Nutzung lassen Sie Caching aktiviert.293Um die Caching-Richtlinie über eine Organisation hinweg festzulegen, setzen Sie eine dieser oder die [TTL-Variablen](#cache-lifetime) in den `env`-Block von [verwalteten Einstellungen](/docs/de/settings#settings-files). Für normale Nutzung lassen Sie Caching aktiviert.

294 294 

295<h2 id="related-resources">295<h2 id="related-resources">

296 Verwandte Ressourcen296 Verwandte Ressourcen

297</h2>297</h2>

298 298 

299* [Lektionen aus dem Aufbau von Claude Code: Prompt Caching ist alles](https://claude.com/blog/lessons-from-building-claude-code-prompt-caching-is-everything): die Designrationale für Plan Mode, aufgeschobenes Tool-Laden und Komprimierung299* [Lektionen aus dem Aufbau von Claude Code: Prompt Caching ist alles](https://claude.com/blog/lessons-from-building-claude-code-prompt-caching-is-everything): die Designrationale für Plan Mode, aufgeschobenes Tool-Laden und Komprimierung

300* [Erkunden Sie das Kontextfenster](/de/context-window): was in den Kontext geladen wird und wann300* [Erkunden Sie das Kontextfenster](/docs/de/context-window): was in den Kontext geladen wird und wann

301* [Token-Nutzung reduzieren](/de/costs#reduce-token-usage): Strategien jenseits von Caching zur Verwaltung der Kontextgröße301* [Token-Nutzung reduzieren](/docs/de/costs#reduce-token-usage): Strategien jenseits von Caching zur Verwaltung der Kontextgröße

302* [Kosten verfolgen und reduzieren](/de/agent-sdk/cost-tracking): Cache-Token-Verfolgung und TTL-Konfiguration für Agent SDK-Aufrufer302* [Kosten verfolgen und reduzieren](/docs/de/agent-sdk/cost-tracking): Cache-Token-Verfolgung und TTL-Konfiguration für Agent SDK-Aufrufer

303* [Prompt Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching): der zugrunde liegende API-Mechanismus, Breakpoints und Preisgestaltung303* [Prompt Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching): der zugrunde liegende API-Mechanismus, Breakpoints und Preisgestaltung