diff --git a/content/de/developer/integration/ai/agentgateway.md b/content/de/developer/integration/ai/agentgateway.md
new file mode 100644
index 00000000..40737389
--- /dev/null
+++ b/content/de/developer/integration/ai/agentgateway.md
@@ -0,0 +1,183 @@
+---
+title: "agentgateway"
+description: "RustFS-Speicheroperationen über das agentgateway AI-Gateway als entfernte MCP-Tools bereitstellen."
+---
+
+[agentgateway](https://github.com/agentgateway/agentgateway) ist ein KI-nativer Proxy für MCP-, A2A- und LLM-Traffic. Sein MCP-Gateway föderiert MCP-Server und stellt sie über das Netzwerk mit Authentifizierung, Policies und OpenTelemetry-Observability bereit. [RustFS bringt einen eigenen MCP-Server mit](https://github.com/rustfs/mcp), der Speicheroperationen als Tools exponiert — jedoch nur über stdio, also als lokaler Subprozess und nicht fernzugreifbar. Diese Anleitung verbindet beide: agentgateway startet den RustFS-MCP-Server als stdio-Target und serviert ihn als entfernten MCP-Endpunkt, sodass jeder MCP-Client RustFS-Speicher über das Gateway bedienen kann. Der Ablauf wurde mit agentgateway `1.7.0`, dem `rustfs/mcp`-Server und RustFS `1.0.6` verifiziert.
+
+Sie benötigen Docker auf dem Gateway-Host und einen erreichbaren RustFS-Server.
+
+## Architektur
+
+```mermaid
+flowchart LR
+ Client["MCP client
IDE / agent / inspector"] -->|"MCP over HTTP"| AGW["agentgateway :3000"]
+ AGW -->|"stdio subprocess"| MCP["rustfs-mcp"]
+ MCP -->|"S3 API"| RustFS["RustFS :9000"]
+```
+
+Das Gateway startet `rustfs-mcp` als Kindprozess und übersetzt zwischen dessen stdio-Transport und dem MCP-Streamable-HTTP-Listener auf Port 3000. Speicheroperationen fließen durch das Gateway — dessen Policies, Rate Limiting und Telemetrie gelten damit auch für Objektspeicher-Toolaufrufe.
+
+:::note[Warum ein Gateway für einen stdio-Server]
+
+Ein stdio-MCP-Server ist nur von der Maschine erreichbar, die ihn startet. agentgateway ergänzt den fehlenden Transport — entfernte Clients verbinden sich über HTTP, während die S3-Zugangsdaten auf dem Gateway-Host bleiben.
+
+:::
+
+## 1. Das RustFS-MCP-Server-Image bauen
+
+Der MCP-Server liegt in einem eigenen Repository. Bauen Sie das Image aus dem Quellcode:
+
+```bash
+git clone https://github.com/rustfs/mcp.git rustfs-mcp
+docker build -t rustfs/rustfs-mcp:latest rustfs-mcp
+```
+
+Das Build ergibt ein Image, das den MCP-Server über stdio ausführt und über die Standard-`AWS_*`-Umgebungsvariablen mit jedem S3-kompatiblen Endpunkt spricht.
+
+## 2. agentgateway konfigurieren
+
+Erstellen Sie die Gateway-Konfiguration. Das Target startet das MCP-Image als Subprozess; der Volume-Mount legt ein Host-Verzeichnis für das Upload-Tool offen, und der Endpunkt zeigt über die Docker-Bridge-Gateway-Adresse auf RustFS:
+
+```yaml title="config.yaml"
+mcp:
+ port: 3000
+ targets:
+ - name: rustfs
+ stdio:
+ cmd: docker
+ args:
+ - run
+ - --rm
+ - -i
+ - -v
+ - /data/agentgateway/demo:/demo
+ - -e
+ - AWS_ACCESS_KEY_ID=
+ - -e
+ - AWS_SECRET_ACCESS_KEY=
+ - -e
+ - AWS_REGION=us-east-1
+ - -e
+ - AWS_ENDPOINT_URL=http://172.17.0.1:9000
+ - rustfs/rustfs-mcp:latest
+```
+
+:::note[Endpunkt-Adressierung aus dem MCP-Container]
+
+Der MCP-Server läuft in einem Container — `127.0.0.1:9000` auf dem RustFS-Host ist für ihn nicht erreichbar. Verwenden Sie die Docker-Bridge-Gateway-Adresse `172.17.0.1:9000` (oder einen gemeinsamen Netzwerk-Alias). Läuft RustFS selbst in Docker in einem eigenen Bridge-Netzwerk, isoliert Docker die Bridges voneinander — hängen Sie beide Container an dasselbe Netzwerk und verwenden Sie den Containernamen.
+
+:::
+
+Starten Sie das Gateway mit dem Konfigurationsinhalt:
+
+```bash
+agentgateway -c "$(cat config.yaml)"
+```
+
+Das Log bestätigt die Listener: das MCP-Bind auf Port 3000, die Admin-UI unter `http://localhost:15000/ui` und einen Stats-Endpunkt auf 15020.
+
+
+
+## 3. RustFS-Tools über das Gateway aufrufen
+
+Der MCP-Inspector treibt das Gateway für die manuelle Verifizierung an:
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp --method tools/list
+```
+
+```json
+"tools": ["create_bucket", "delete_bucket", "get_object", "list_buckets", "list_objects", "upload_file"]
+```
+
+Erstellen Sie einen Bucket und laden Sie eine Datei über das Gateway hoch:
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name create_bucket \
+ --tool-arg bucket_name=agw-demo
+
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name upload_file \
+ --tool-arg local_file_path=/demo/hello.txt \
+ --tool-arg bucket_name=agw-demo --tool-arg object_key=hello.txt
+```
+
+```text
+✅ **File uploaded successfully!**
+```
+
+:::note[Der Upload-Pfad liegt auf der MCP-Server-Seite]
+
+`upload_file` liest `local_file_path` aus dem Dateisystem des Prozesses, der den MCP-Server ausführt — also aus dem Container heraus. Der Volume-Mount `-v /data/agentgateway/demo:/demo` aus Schritt 2 legt ein Host-Verzeichnis als `/demo` im Container offen, weshalb das Tool die Datei lesen kann.
+
+:::
+
+## 4. Die Objekte in RustFS bestätigen
+
+Das über das Gateway geschriebene Objekt landet wie jeder S3-Schreibvorgang im Bucket. Bestätigen Sie es mit der S3-API und ersetzen Sie alle Verbindungsplatzhalter:
+
+```bash
+aws s3api list-objects --bucket agw-demo \
+ --endpoint-url http://localhost:9000
+```
+
+```json
+{
+ "Contents": [
+ {
+ "Key": "hello.txt",
+ "Size": 39,
+ "StorageClass": "STANDARD"
+ }
+ ]
+}
+```
+
+Lesen Sie es über das Gateway zurück und schließen Sie den Kreis:
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name get_object \
+ --tool-arg bucket_name=agw-demo --tool-arg object_key=hello.txt --tool-arg mode=read
+```
+
+ Content: hello from rustfs-mcp via agentgateway
+
+
+
+## Verifizierungsergebnisse
+
+| Prüfung | Erwartetes Ergebnis |
+| --- | --- |
+| MCP-Handshake über das Gateway | `serverInfo.name` meldet `rustfs-mcp-server` mit Protokoll `2025-03-26` |
+| `tools/list` | Alle sechs Speicher-Tools föderiert: `create_bucket`, `delete_bucket`, `get_object`, `list_buckets`, `list_objects`, `upload_file` |
+| `create_bucket` über das Gateway | Bucket erscheint in RustFS |
+| `upload_file` über das Gateway | Objekt landet im Bucket; sichtbar in der Konsole und über die S3-API |
+| `get_object` über das Gateway | Inhalt stimmt byteweise mit der hochgeladenen Datei überein |
+| Gateway-Admin-UI | Zeigt den konfigurierten MCP-Server und Port |
+
+## Fehlerbehebung
+
+### `Error: invalid config: invalid type: string "config.yaml"`
+
+Der Config-Parameter erwartet den Konfigurationsinhalt, nicht einen Pfad. Übergeben Sie den Dateiinhalt: `agentgateway -c "$(cat config.yaml)"`.
+
+### MCP-Tools laufen in Timeout oder melden Verbindungsfehler
+
+Der MCP-Container erreicht die RustFS-Adresse nicht. `127.0.0.1:9000` im Container ist der Container selbst — verwenden Sie `172.17.0.1:9000` (Docker-Bridge-Gateway) oder einen gemeinsamen Netzwerk-Alias, siehe Schritt 2.
+
+### `upload_file` schlägt mit fehlender lokaler Datei fehl
+
+Der Pfad wird im MCP-Server-Container aufgelöst. Mounten Sie das Host-Verzeichnis mit `-v` in den Container und referenzieren Sie den gemounteten Pfad, siehe Schritt 2.
+
+### `GET /mcp` liefert `406 Not Acceptable`
+
+Erwartet: Der Streamable-HTTP-Endpunkt akzeptiert nur `POST`-Anfragen mit `Accept: application/json, text/event-stream`-Headern — verwenden Sie einen MCP-Client wie den Inspector statt eines Browsers.
+
+## Nächste Schritte
+
+- Die Referenz des [RustFS-MCP-Servers](/developer/mcp) enthält das vollständige Tool-Set.
+- Erstellen Sie dedizierte Zugangsdaten mit der [Zugangsdatenverwaltung](/security-compliance/iam/access-token) für die Gateway-Identität.
+- Folgen Sie der [agentgateway-Dokumentation](https://agentgateway.dev/docs/) für Authentifizierungs-Policies, Rate Limiting und OpenTelemetry auf demselben Gateway.
diff --git a/content/de/developer/integration/ai/images/agentgateway-ui.png b/content/de/developer/integration/ai/images/agentgateway-ui.png
new file mode 100644
index 00000000..865b4673
Binary files /dev/null and b/content/de/developer/integration/ai/images/agentgateway-ui.png differ
diff --git a/content/de/developer/integration/ai/images/rustfs-agentgateway-bucket.png b/content/de/developer/integration/ai/images/rustfs-agentgateway-bucket.png
new file mode 100644
index 00000000..cda67ad6
Binary files /dev/null and b/content/de/developer/integration/ai/images/rustfs-agentgateway-bucket.png differ
diff --git a/content/de/developer/integration/ai/meta.json b/content/de/developer/integration/ai/meta.json
index 4deb8701..fee6d822 100644
--- a/content/de/developer/integration/ai/meta.json
+++ b/content/de/developer/integration/ai/meta.json
@@ -8,6 +8,7 @@
"dify",
"ragflow",
"cocoindex",
- "feast"
+ "feast",
+ "agentgateway"
]
}
diff --git a/content/de/developer/mcp.md b/content/de/developer/mcp.md
index 9082f7bb..32066b3c 100644
--- a/content/de/developer/mcp.md
+++ b/content/de/developer/mcp.md
@@ -192,6 +192,8 @@ Trae gibt die folgende Antwort zurück:
Trae verwendet den Modus **Builder with MCP** und ruft das Tool `list_buckets` auf, um alle Buckets in der konfigurierten RustFS-Instanz aufzulisten. Andere Tools funktionieren auf dieselbe Weise.
+Um diesen Server nicht lokal, sondern fernzubetreiben, föderiert [agentgateway](integration/ai/agentgateway.md) den RustFS-MCP-Server als stdio-Target und stellt ihn über HTTP mit Authentifizierung und Telemetrie bereit.
+
## Verfügbare Tools
Der MCP-Server stellt die folgenden Tools bereit, die KI-Assistenten verwenden können:
diff --git a/content/en/developer/integration/ai/agentgateway.md b/content/en/developer/integration/ai/agentgateway.md
new file mode 100644
index 00000000..160759ca
--- /dev/null
+++ b/content/en/developer/integration/ai/agentgateway.md
@@ -0,0 +1,183 @@
+---
+title: "agentgateway"
+description: "Expose RustFS storage operations as remote MCP tools through the agentgateway AI gateway."
+---
+
+[agentgateway](https://github.com/agentgateway/agentgateway) is an AI-native proxy for MCP, A2A, and LLM traffic. Its MCP gateway federates MCP servers and exposes them over the network with authentication, policies, and OpenTelemetry observability. [RustFS ships its own MCP server](https://github.com/rustfs/mcp) exposing storage operations as tools, but over stdio only — usable as a local subprocess, not remotely. This guide connects the two: agentgateway launches the RustFS MCP server as a stdio target and serves it as a remote MCP endpoint, so any MCP client can operate RustFS storage through the gateway. The workflow was verified with agentgateway `1.7.0`, the `rustfs/mcp` server, and RustFS `1.0.6`.
+
+You need Docker on the gateway host and a reachable RustFS server.
+
+## Architecture
+
+```mermaid
+flowchart LR
+ Client["MCP client
IDE / agent / inspector"] -->|"MCP over HTTP"| AGW["agentgateway :3000"]
+ AGW -->|"stdio subprocess"| MCP["rustfs-mcp"]
+ MCP -->|"S3 API"| RustFS["RustFS :9000"]
+```
+
+The gateway spawns `rustfs-mcp` as a child process and translates between its stdio transport and the MCP Streamable HTTP listener on port 3000. Storage operations flow through the gateway, so its policies, rate limiting, and telemetry apply to object-storage tool calls as well.
+
+:::note[Why a gateway for a stdio server]
+
+A stdio MCP server is only reachable from the machine that launches it. agentgateway adds the missing transport — remote clients connect over HTTP while the S3 credentials stay on the gateway host.
+
+:::
+
+## 1. Build the RustFS MCP server image
+
+The MCP server lives in its own repository. Build the image from source:
+
+```bash
+git clone https://github.com/rustfs/mcp.git rustfs-mcp
+docker build -t rustfs/rustfs-mcp:latest rustfs-mcp
+```
+
+The build produces an image that runs the MCP server over stdio and talks to any S3-compatible endpoint configured through the standard `AWS_*` environment variables.
+
+## 2. Configure agentgateway
+
+Create the gateway configuration. The target launches the MCP image as a subprocess; the volume mount exposes a host directory for the upload tool, and the endpoint points at RustFS through the Docker bridge gateway address:
+
+```yaml title="config.yaml"
+mcp:
+ port: 3000
+ targets:
+ - name: rustfs
+ stdio:
+ cmd: docker
+ args:
+ - run
+ - --rm
+ - -i
+ - -v
+ - /data/agentgateway/demo:/demo
+ - -e
+ - AWS_ACCESS_KEY_ID=
+ - -e
+ - AWS_SECRET_ACCESS_KEY=
+ - -e
+ - AWS_REGION=us-east-1
+ - -e
+ - AWS_ENDPOINT_URL=http://172.17.0.1:9000
+ - rustfs/rustfs-mcp:latest
+```
+
+:::note[Endpoint addressing from the MCP container]
+
+The MCP server runs in a container, so `127.0.0.1:9000` on the RustFS host is not reachable from it. Use the Docker bridge gateway address `172.17.0.1:9000` (or a shared network alias). If RustFS itself runs in Docker on a custom bridge network, Docker isolates bridges from each other — attach both containers to the same network and use the container name instead.
+
+:::
+
+Start the gateway with the configuration content:
+
+```bash
+agentgateway -c "$(cat config.yaml)"
+```
+
+The log confirms the listeners: the MCP bind on port 3000, the admin UI at `http://localhost:15000/ui`, and a stats endpoint on 15020.
+
+
+
+## 3. Call RustFS tools through the gateway
+
+The MCP inspector drives the gateway for manual verification:
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp --method tools/list
+```
+
+```json
+"tools": ["create_bucket", "delete_bucket", "get_object", "list_buckets", "list_objects", "upload_file"]
+```
+
+Create a bucket and upload a file through the gateway:
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name create_bucket \
+ --tool-arg bucket_name=agw-demo
+
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name upload_file \
+ --tool-arg local_file_path=/demo/hello.txt \
+ --tool-arg bucket_name=agw-demo --tool-arg object_key=hello.txt
+```
+
+```text
+✅ **File uploaded successfully!**
+```
+
+:::note[The upload path is on the MCP server side]
+
+`upload_file` reads `local_file_path` from the filesystem of the process running the MCP server — inside the container. The volume mount `-v /data/agentgateway/demo:/demo` in step 2 exposes a host directory at `/demo` in the container, which is why the tool can read the file.
+
+:::
+
+## 4. Confirm the objects in RustFS
+
+The object written through the gateway lands in the bucket like any S3 write. Confirm with the S3 API, replacing all connection placeholders:
+
+```bash
+aws s3api list-objects --bucket agw-demo \
+ --endpoint-url http://localhost:9000
+```
+
+```json
+{
+ "Contents": [
+ {
+ "Key": "hello.txt",
+ "Size": 39,
+ "StorageClass": "STANDARD"
+ }
+ ]
+}
+```
+
+Read it back through the gateway to close the loop:
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name get_object \
+ --tool-arg bucket_name=agw-demo --tool-arg object_key=hello.txt --tool-arg mode=read
+```
+
+ Content: hello from rustfs-mcp via agentgateway
+
+
+
+## Validation results
+
+| Check | Expected result |
+| --- | --- |
+| MCP handshake through the gateway | `serverInfo.name` reports `rustfs-mcp-server` with protocol `2025-03-26` |
+| `tools/list` | All six storage tools federated: `create_bucket`, `delete_bucket`, `get_object`, `list_buckets`, `list_objects`, `upload_file` |
+| `create_bucket` through the gateway | Bucket appears in RustFS |
+| `upload_file` through the gateway | Object lands in the bucket; visible in the console and via the S3 API |
+| `get_object` through the gateway | Content matches the uploaded file byte for byte |
+| Gateway admin UI | Reports the configured MCP server and port |
+
+## Troubleshooting
+
+### `Error: invalid config: invalid type: string "config.yaml"`
+
+The config flag consumes the configuration content, not a path. Pass the file contents: `agentgateway -c "$(cat config.yaml)"`.
+
+### MCP tools time out or report connection errors
+
+The MCP container cannot reach the RustFS address. `127.0.0.1:9000` inside the container is the container itself — use `172.17.0.1:9000` (Docker bridge gateway) or a shared network alias, as in step 2.
+
+### `upload_file` fails with a missing local file
+
+The path is resolved inside the MCP server container. Mount the host directory into the container with `-v` and reference the mounted path, as in step 2.
+
+### `GET /mcp` returns `406 Not Acceptable`
+
+Expected: the Streamable HTTP endpoint only accepts `POST` requests with `Accept: application/json, text/event-stream` headers — use an MCP client such as the inspector instead of a browser.
+
+## Next steps
+
+- Review the [RustFS MCP server](/developer/mcp) reference for the full tool set.
+- Create dedicated credentials with [Access Key Management](/security-compliance/iam/access-token) for the gateway identity.
+- Follow the [agentgateway documentation](https://agentgateway.dev/docs/) for authentication policies, rate limiting, and OpenTelemetry on the same gateway.
diff --git a/content/en/developer/integration/ai/images/agentgateway-ui.png b/content/en/developer/integration/ai/images/agentgateway-ui.png
new file mode 100644
index 00000000..865b4673
Binary files /dev/null and b/content/en/developer/integration/ai/images/agentgateway-ui.png differ
diff --git a/content/en/developer/integration/ai/images/rustfs-agentgateway-bucket.png b/content/en/developer/integration/ai/images/rustfs-agentgateway-bucket.png
new file mode 100644
index 00000000..cda67ad6
Binary files /dev/null and b/content/en/developer/integration/ai/images/rustfs-agentgateway-bucket.png differ
diff --git a/content/en/developer/integration/ai/meta.json b/content/en/developer/integration/ai/meta.json
index 4deb8701..fee6d822 100644
--- a/content/en/developer/integration/ai/meta.json
+++ b/content/en/developer/integration/ai/meta.json
@@ -8,6 +8,7 @@
"dify",
"ragflow",
"cocoindex",
- "feast"
+ "feast",
+ "agentgateway"
]
}
diff --git a/content/en/developer/mcp.md b/content/en/developer/mcp.md
index c2607759..1c450b8f 100644
--- a/content/en/developer/mcp.md
+++ b/content/en/developer/mcp.md
@@ -196,6 +196,8 @@ Trae returns the following response:
Trae uses **Builder with MCP** mode, calling the `list_buckets` tool to list all buckets in the configured RustFS instance. Other tools work the same way.
+To expose this server remotely instead of running it locally, [agentgateway](integration/ai/agentgateway.md) federates the RustFS MCP server as a stdio target and serves it over HTTP with authentication and telemetry.
+
## Available tools
The MCP server exposes the following tools that AI assistants can use:
diff --git a/content/fr/developer/integration/ai/agentgateway.md b/content/fr/developer/integration/ai/agentgateway.md
new file mode 100644
index 00000000..7df2caa2
--- /dev/null
+++ b/content/fr/developer/integration/ai/agentgateway.md
@@ -0,0 +1,183 @@
+---
+title: "agentgateway"
+description: "Exposer les opérations de stockage RustFS comme outils MCP distants via la passerelle agentgateway."
+---
+
+[agentgateway](https://github.com/agentgateway/agentgateway) est un proxy IA-natif pour le trafic MCP, A2A et LLM. Sa passerelle MCP fédère les serveurs MCP et les expose sur le réseau avec authentification, politiques et observabilité OpenTelemetry. [RustFS embarque son propre serveur MCP](https://github.com/rustfs/mcp) exposant les opérations de stockage comme outils, mais en stdio uniquement — utilisable comme sous-processus local, pas à distance. Ce guide connecte les deux : agentgateway lance le serveur MCP RustFS comme cible stdio et le sert comme point de terminaison MCP distant, afin que tout client MCP puisse opérer le stockage RustFS via la passerelle. Le workflow a été vérifié avec agentgateway `1.7.0`, le serveur `rustfs/mcp` et RustFS `1.0.6`.
+
+Vous avez besoin de Docker sur l'hôte de la passerelle et d'un serveur RustFS joignable.
+
+## Architecture
+
+```mermaid
+flowchart LR
+ Client["MCP client
IDE / agent / inspector"] -->|"MCP over HTTP"| AGW["agentgateway :3000"]
+ AGW -->|"stdio subprocess"| MCP["rustfs-mcp"]
+ MCP -->|"S3 API"| RustFS["RustFS :9000"]
+```
+
+La passerelle lance `rustfs-mcp` comme processus enfant et fait la translation entre son transport stdio et l'écoute MCP Streamable HTTP sur le port 3000. Les opérations de stockage passent par la passerelle — ses politiques, sa limitation de débit et sa télémétrie s'appliquent donc aussi aux appels d'outils de stockage objet.
+
+:::note[Pourquoi une passerelle pour un serveur stdio]
+
+Un serveur MCP stdio n'est joignable que depuis la machine qui le lance. agentgateway ajoute le transport manquant — les clients distants se connectent en HTTP pendant que les identifiants S3 restent sur l'hôte de la passerelle.
+
+:::
+
+## 1. Construire l'image du serveur MCP RustFS
+
+Le serveur MCP vit dans son propre dépôt. Construisez l'image depuis les sources :
+
+```bash
+git clone https://github.com/rustfs/mcp.git rustfs-mcp
+docker build -t rustfs/rustfs-mcp:latest rustfs-mcp
+```
+
+Le build produit une image qui exécute le serveur MCP en stdio et dialogue avec tout point de terminaison compatible S3 configuré via les variables d'environnement `AWS_*` standard.
+
+## 2. Configurer agentgateway
+
+Créez la configuration de la passerelle. La cible lance l'image MCP comme sous-processus ; le montage de volume expose un répertoire hôte pour l'outil de téléversement, et le point de terminaison pointe vers RustFS via l'adresse de passerelle du bridge Docker :
+
+```yaml title="config.yaml"
+mcp:
+ port: 3000
+ targets:
+ - name: rustfs
+ stdio:
+ cmd: docker
+ args:
+ - run
+ - --rm
+ - -i
+ - -v
+ - /data/agentgateway/demo:/demo
+ - -e
+ - AWS_ACCESS_KEY_ID=
+ - -e
+ - AWS_SECRET_ACCESS_KEY=
+ - -e
+ - AWS_REGION=us-east-1
+ - -e
+ - AWS_ENDPOINT_URL=http://172.17.0.1:9000
+ - rustfs/rustfs-mcp:latest
+```
+
+:::note[Adressage du point de terminaison depuis le conteneur MCP]
+
+Le serveur MCP tourne dans un conteneur — `127.0.0.1:9000` sur l'hôte RustFS ne lui est pas joignable. Utilisez l'adresse de passerelle du bridge Docker `172.17.0.1:9000` (ou un alias de réseau partagé). Si RustFS tourne lui-même dans Docker sur un réseau bridge personnalisé, Docker isole les bridges entre eux — rattachez les deux conteneurs au même réseau et utilisez le nom du conteneur.
+
+:::
+
+Démarrez la passerelle avec le contenu de la configuration :
+
+```bash
+agentgateway -c "$(cat config.yaml)"
+```
+
+Le journal confirme les écouteurs : le bind MCP sur le port 3000, l'UI d'administration à `http://localhost:15000/ui` et un endpoint de statistiques sur 15020.
+
+
+
+## 3. Appeler les outils RustFS via la passerelle
+
+L'inspecteur MCP pilote la passerelle pour une vérification manuelle :
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp --method tools/list
+```
+
+```json
+"tools": ["create_bucket", "delete_bucket", "get_object", "list_buckets", "list_objects", "upload_file"]
+```
+
+Créez un bucket et téléversez un fichier via la passerelle :
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name create_bucket \
+ --tool-arg bucket_name=agw-demo
+
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name upload_file \
+ --tool-arg local_file_path=/demo/hello.txt \
+ --tool-arg bucket_name=agw-demo --tool-arg object_key=hello.txt
+```
+
+```text
+✅ **File uploaded successfully!**
+```
+
+:::note[Le chemin de téléversement est côté serveur MCP]
+
+`upload_file` lit `local_file_path` depuis le système de fichiers du processus exécutant le serveur MCP — donc depuis l'intérieur du conteneur. Le montage `-v /data/agentgateway/demo:/demo` de l'étape 2 expose un répertoire hôte en `/demo` dans le conteneur, ce qui permet à l'outil de lire le fichier.
+
+:::
+
+## 4. Confirmer les objets dans RustFS
+
+L'objet écrit via la passerelle atterrit dans le bucket comme toute écriture S3. Confirmez avec l'API S3, en remplaçant tous les paramètres fictifs :
+
+```bash
+aws s3api list-objects --bucket agw-demo \
+ --endpoint-url http://localhost:9000
+```
+
+```json
+{
+ "Contents": [
+ {
+ "Key": "hello.txt",
+ "Size": 39,
+ "StorageClass": "STANDARD"
+ }
+ ]
+}
+```
+
+Relisez-le via la passerelle pour boucler la boucle :
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name get_object \
+ --tool-arg bucket_name=agw-demo --tool-arg object_key=hello.txt --tool-arg mode=read
+```
+
+ Content: hello from rustfs-mcp via agentgateway
+
+
+
+## Résultats de validation
+
+| Vérification | Résultat attendu |
+| --- | --- |
+| Poignée de main MCP via la passerelle | `serverInfo.name` rapporte `rustfs-mcp-server` avec le protocole `2025-03-26` |
+| `tools/list` | Les six outils de stockage fédérés : `create_bucket`, `delete_bucket`, `get_object`, `list_buckets`, `list_objects`, `upload_file` |
+| `create_bucket` via la passerelle | Le bucket apparaît dans RustFS |
+| `upload_file` via la passerelle | L'objet atterrit dans le bucket ; visible dans la console et via l'API S3 |
+| `get_object` via la passerelle | Le contenu correspond octet par octet au fichier téléversé |
+| UI d'administration de la passerelle | Rapporte le serveur MCP configuré et le port |
+
+## Dépannage
+
+### `Error: invalid config: invalid type: string "config.yaml"`
+
+Le paramètre de configuration attend le contenu de la configuration, pas un chemin. Passez le contenu du fichier : `agentgateway -c "$(cat config.yaml)"`.
+
+### Les outils MCP expirent ou signalent des erreurs de connexion
+
+Le conteneur MCP ne peut pas joindre l'adresse RustFS. `127.0.0.1:9000` dans le conteneur désigne le conteneur lui-même — utilisez `172.17.0.1:9000` (passerelle du bridge Docker) ou un alias de réseau partagé, voir l'étape 2.
+
+### `upload_file` échoue avec un fichier local manquant
+
+Le chemin est résolu dans le conteneur du serveur MCP. Montez le répertoire hôte dans le conteneur avec `-v` et référencez le chemin monté, voir l'étape 2.
+
+### `GET /mcp` renvoie `406 Not Acceptable`
+
+Attendu : le point de terminaison Streamable HTTP n'accepte que des requêtes `POST` avec les en-têtes `Accept: application/json, text/event-stream` — utilisez un client MCP comme l'inspecteur plutôt qu'un navigateur.
+
+## Prochaines étapes
+
+- La référence du [serveur MCP RustFS](/developer/mcp) décrit l'ensemble complet des outils.
+- Créez des identifiants dédiés avec la [gestion des clés d'accès](/security-compliance/iam/access-token) pour l'identité de la passerelle.
+- Suivez la [documentation agentgateway](https://agentgateway.dev/docs/) pour les politiques d'authentification, la limitation de débit et OpenTelemetry sur la même passerelle.
diff --git a/content/fr/developer/integration/ai/images/agentgateway-ui.png b/content/fr/developer/integration/ai/images/agentgateway-ui.png
new file mode 100644
index 00000000..865b4673
Binary files /dev/null and b/content/fr/developer/integration/ai/images/agentgateway-ui.png differ
diff --git a/content/fr/developer/integration/ai/images/rustfs-agentgateway-bucket.png b/content/fr/developer/integration/ai/images/rustfs-agentgateway-bucket.png
new file mode 100644
index 00000000..cda67ad6
Binary files /dev/null and b/content/fr/developer/integration/ai/images/rustfs-agentgateway-bucket.png differ
diff --git a/content/fr/developer/integration/ai/meta.json b/content/fr/developer/integration/ai/meta.json
index bfc5c3e8..cf00a790 100644
--- a/content/fr/developer/integration/ai/meta.json
+++ b/content/fr/developer/integration/ai/meta.json
@@ -8,6 +8,7 @@
"dify",
"ragflow",
"cocoindex",
- "feast"
+ "feast",
+ "agentgateway"
]
}
diff --git a/content/fr/developer/mcp.md b/content/fr/developer/mcp.md
index 163b97de..b5ca49a8 100644
--- a/content/fr/developer/mcp.md
+++ b/content/fr/developer/mcp.md
@@ -192,6 +192,8 @@ Trae renvoie la réponse suivante :
Trae utilise le mode **Builder with MCP** (générateur avec MCP) et appelle l’outil `list_buckets` pour lister tous les compartiments de l’instance RustFS configurée. Les autres outils fonctionnent de la même manière.
+Pour exposer ce serveur à distance au lieu de l'exécuter localement, [agentgateway](integration/ai/agentgateway.md) fédère le serveur MCP RustFS comme cible stdio et le sert en HTTP avec authentification et télémétrie.
+
## Outils disponibles
Le serveur MCP expose les outils suivants, que les assistants d’IA peuvent utiliser :
diff --git a/content/ja/developer/integration/ai/agentgateway.md b/content/ja/developer/integration/ai/agentgateway.md
new file mode 100644
index 00000000..f1252a58
--- /dev/null
+++ b/content/ja/developer/integration/ai/agentgateway.md
@@ -0,0 +1,183 @@
+---
+title: "agentgateway"
+description: "agentgateway AI ゲートウェイ経由で RustFS のストレージ操作をリモート MCP ツールとして公開する。"
+---
+
+[agentgateway](https://github.com/agentgateway/agentgateway) は MCP・A2A・LLM トラフィック向けの AI ネイティブ プロキシです。その MCP ゲートウェイは MCP サーバーをフェデレーションし、認証・ポリシー・OpenTelemetry オブザーバビリティ付きでネットワーク経由で公開します。[RustFS は独自の MCP サーバー](https://github.com/rustfs/mcp)を同梱しており、ストレージ操作をツールとして公開していますが、トランスポートは stdio のみです。ローカルのサブプロセスとしてなら使えますが、リモートからはアクセスできません。このガイドは両者を接続します。agentgateway が RustFS MCP サーバーを stdio ターゲットとして起動し、リモート MCP エンドポイントとして提供することで、どんな MCP クライアントからもゲートウェイ経由で RustFS ストレージを操作できるようになります。このワークフローは agentgateway `1.7.0`、`rustfs/mcp` サーバー、RustFS `1.0.6` で検証しました。
+
+ゲートウェイホストの Docker と、到達可能な RustFS サーバーが必要です。
+
+## アーキテクチャ
+
+```mermaid
+flowchart LR
+ Client["MCP client
IDE / agent / inspector"] -->|"MCP over HTTP"| AGW["agentgateway :3000"]
+ AGW -->|"stdio subprocess"| MCP["rustfs-mcp"]
+ MCP -->|"S3 API"| RustFS["RustFS :9000"]
+```
+
+ゲートウェイは `rustfs-mcp` を子プロセスとして起動し、その stdio トランスポートとポート 3000 の MCP Streamable HTTP リスナーの間を変換します。ストレージ操作はゲートウェイを経由するため、ゲートウェイのポリシー・レート制限・テレメトリーがオブジェクトストレージのツール呼び出しにも適用されます。
+
+:::note[stdio サーバーにゲートウェイが必要な理由]
+
+stdio の MCP サーバーは、それを起動したマシンからしかアクセスできません。agentgateway が欠けているトランスポートを補います。リモートクライアントは HTTP で接続し、S3 の認証情報はゲートウェイホスト上にとどまります。
+
+:::
+
+## 1. RustFS MCP サーバーイメージをビルドする
+
+MCP サーバーは独立リポジトリにあります。ソースからイメージをビルドします:
+
+```bash
+git clone https://github.com/rustfs/mcp.git rustfs-mcp
+docker build -t rustfs/rustfs-mcp:latest rustfs-mcp
+```
+
+ビルドで得られるイメージは stdio で MCP サーバーを実行し、標準の `AWS_*` 環境変数で設定された任意の S3 互換エンドポイントと通信します。
+
+## 2. agentgateway を設定する
+
+ゲートウェイの設定を作成します。ターゲットは MCP イメージをサブプロセスとして起動し、ボリュームマウントがアップロードツール用のホストディレクトリを公開し、エンドポイントは Docker ブリッジゲートウェイアドレス経由で RustFS を指します:
+
+```yaml title="config.yaml"
+mcp:
+ port: 3000
+ targets:
+ - name: rustfs
+ stdio:
+ cmd: docker
+ args:
+ - run
+ - --rm
+ - -i
+ - -v
+ - /data/agentgateway/demo:/demo
+ - -e
+ - AWS_ACCESS_KEY_ID=
+ - -e
+ - AWS_SECRET_ACCESS_KEY=
+ - -e
+ - AWS_REGION=us-east-1
+ - -e
+ - AWS_ENDPOINT_URL=http://172.17.0.1:9000
+ - rustfs/rustfs-mcp:latest
+```
+
+:::note[MCP コンテナからのエンドポイントアドレス指定]
+
+MCP サーバーはコンテナ内で動くため、RustFS ホストの `127.0.0.1:9000` には到達できません。Docker ブリッジゲートウェイアドレス `172.17.0.1:9000`(または共有ネットワークエイリアス)を使ってください。RustFS 自身もカスタムブリッジネットワークの Docker で動いている場合、Docker はブリッジ同士を分離します。両コンテナを同じネットワークに接続し、コンテナ名を使ってください。
+
+:::
+
+設定内容を渡してゲートウェイを起動します:
+
+```bash
+agentgateway -c "$(cat config.yaml)"
+```
+
+ログに各リスナーが確認できます。ポート 3000 の MCP バインド、`http://localhost:15000/ui` の管理 UI、15020 の stats エンドポイントです。
+
+
+
+## 3. ゲートウェイ経由で RustFS ツールを呼び出す
+
+MCP インスペクターを使うと手動検証のためにゲートウェイを操作できます:
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp --method tools/list
+```
+
+```json
+"tools": ["create_bucket", "delete_bucket", "get_object", "list_buckets", "list_objects", "upload_file"]
+```
+
+ゲートウェイ経由でバケットを作成し、ファイルをアップロードします:
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name create_bucket \
+ --tool-arg bucket_name=agw-demo
+
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name upload_file \
+ --tool-arg local_file_path=/demo/hello.txt \
+ --tool-arg bucket_name=agw-demo --tool-arg object_key=hello.txt
+```
+
+```text
+✅ **File uploaded successfully!**
+```
+
+:::note[アップロードパスは MCP サーバー側]
+
+`upload_file` は MCP サーバーを実行しているプロセスのファイルシステムから `local_file_path` を読みます。つまりコンテナ内です。手順 2 のボリュームマウント `-v /data/agentgateway/demo:/demo` がホストディレクトリをコンテナ内の `/demo` として公開するため、ツールはファイルを読めます。
+
+:::
+
+## 4. RustFS 内のオブジェクトを確認する
+
+ゲートウェイ経由で書き込まれたオブジェクトは、通常の S3 書き込みと同様にバケットに着地します。S3 API で確認し、接続プレースホルダーをすべて置き換えてください:
+
+```bash
+aws s3api list-objects --bucket agw-demo \
+ --endpoint-url http://localhost:9000
+```
+
+```json
+{
+ "Contents": [
+ {
+ "Key": "hello.txt",
+ "Size": 39,
+ "StorageClass": "STANDARD"
+ }
+ ]
+}
+```
+
+ゲートウェイ経由で読み戻してループを閉じます:
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name get_object \
+ --tool-arg bucket_name=agw-demo --tool-arg object_key=hello.txt --tool-arg mode=read
+```
+
+ Content: hello from rustfs-mcp via agentgateway
+
+
+
+## 検証結果
+
+| 検査 | 期待される結果 |
+| --- | --- |
+| ゲートウェイ経由の MCP ハンドシェイク | `serverInfo.name` が `rustfs-mcp-server`、プロトコル `2025-03-26` を報告 |
+| `tools/list` | 6 つのストレージツールすべてがフェデレーション:`create_bucket`、`delete_bucket`、`get_object`、`list_buckets`、`list_objects`、`upload_file` |
+| ゲートウェイ経由の `create_bucket` | バケットが RustFS に現れる |
+| ゲートウェイ経由の `upload_file` | オブジェクトがバケットに着地。コンソールと S3 API の両方で見える |
+| ゲートウェイ経由の `get_object` | 内容がアップロードしたファイルとバイト単位で一致 |
+| ゲートウェイ管理 UI | 構成済みの MCP サーバーとポートを表示 |
+
+## トラブルシューティング
+
+### `Error: invalid config: invalid type: string "config.yaml"`
+
+config パラメータが受け取るのは設定の中身であり、パスではありません。ファイルの内容を渡してください:`agentgateway -c "$(cat config.yaml)"`。
+
+### MCP ツールがタイムアウトしたり接続エラーを報告したりする
+
+MCP コンテナから RustFS のアドレスに到達できていません。コンテナ内の `127.0.0.1:9000` はコンテナ自身を指します。`172.17.0.1:9000`(Docker ブリッジゲートウェイ)か共有ネットワークエイリアスを使ってください。手順 2 を参照。
+
+### `upload_file` がローカルファイル未存在で失敗する
+
+パスは MCP サーバーコンテナ内で解決されます。`-v` でホストディレクトリをコンテナにマウントし、マウント後のパスを参照してください。手順 2 を参照。
+
+### `GET /mcp` が `406 Not Acceptable` を返す
+
+想定された動作です。Streamable HTTP エンドポイントは `Accept: application/json, text/event-stream` ヘッダー付きの `POST` のみを受け付けます。ブラウザではなくインスペクターなどの MCP クライアントを使ってください。
+
+## 次のステップ
+
+- ツール一式の全体像は [RustFS MCP サーバー](/developer/mcp)のリファレンスを参照してください。
+- ゲートウェイのアイデンティティ用に [アクセスキー管理](/security-compliance/iam/access-token) で専用の認証情報を作成してください。
+- [agentgateway ドキュメント](https://agentgateway.dev/docs/) に従い、同じゲートウェイで認証ポリシー・レート制限・OpenTelemetry を活用してください。
diff --git a/content/ja/developer/integration/ai/images/agentgateway-ui.png b/content/ja/developer/integration/ai/images/agentgateway-ui.png
new file mode 100644
index 00000000..865b4673
Binary files /dev/null and b/content/ja/developer/integration/ai/images/agentgateway-ui.png differ
diff --git a/content/ja/developer/integration/ai/images/rustfs-agentgateway-bucket.png b/content/ja/developer/integration/ai/images/rustfs-agentgateway-bucket.png
new file mode 100644
index 00000000..cda67ad6
Binary files /dev/null and b/content/ja/developer/integration/ai/images/rustfs-agentgateway-bucket.png differ
diff --git a/content/ja/developer/integration/ai/meta.json b/content/ja/developer/integration/ai/meta.json
index 4deb8701..fee6d822 100644
--- a/content/ja/developer/integration/ai/meta.json
+++ b/content/ja/developer/integration/ai/meta.json
@@ -8,6 +8,7 @@
"dify",
"ragflow",
"cocoindex",
- "feast"
+ "feast",
+ "agentgateway"
]
}
diff --git a/content/ja/developer/mcp.md b/content/ja/developer/mcp.md
index bd9bfd89..6e2887d1 100644
--- a/content/ja/developer/mcp.md
+++ b/content/ja/developer/mcp.md
@@ -192,6 +192,8 @@ Trae は次の応答を返します。
Trae は **Builder with MCP**(MCP を使うビルダー)モードで `list_buckets` ツールを呼び出し、設定済みの RustFS インスタンスにあるバケットをすべて列挙します。他のツールも同じように動作します。
+ローカルで実行する代わりにリモート公開したい場合は、[agentgateway](integration/ai/agentgateway.md) が RustFS MCP サーバーを stdio ターゲットとしてフェデレーションし、認証とテレメトリー付きの HTTP で提供します。
+
## 利用できるツール [#available-tools]
MCP サーバーは、AI アシスタントが使える次のツールを公開します。
diff --git a/content/zh/developer/integration/ai/agentgateway.md b/content/zh/developer/integration/ai/agentgateway.md
new file mode 100644
index 00000000..e32df314
--- /dev/null
+++ b/content/zh/developer/integration/ai/agentgateway.md
@@ -0,0 +1,183 @@
+---
+title: "agentgateway"
+description: "通过 agentgateway AI 网关把 RustFS 存储操作暴露为远程 MCP 工具。"
+---
+
+[agentgateway](https://github.com/agentgateway/agentgateway) 是面向 MCP、A2A 和 LLM 流量的 AI 原生代理。它的 MCP 网关可以联邦多个 MCP server 并通过网络暴露,附带认证、策略和 OpenTelemetry 可观测性。[RustFS 自带 MCP server](https://github.com/rustfs/mcp),把存储操作暴露为工具,但只有 stdio 传输——只能作为本地子进程使用,无法远程访问。本指南把两者连接起来:agentgateway 以 stdio target 拉起 RustFS MCP server,并将其作为远程 MCP 端点提供服务,任何 MCP 客户端都能通过网关操作 RustFS 存储。整个流程在 agentgateway `1.7.0`、`rustfs/mcp` server 与 RustFS `1.0.6` 上验证通过。
+
+你需要网关宿主机上的 Docker 和一台可达的 RustFS 服务器。
+
+## 架构
+
+```mermaid
+flowchart LR
+ Client["MCP client
IDE / agent / inspector"] -->|"MCP over HTTP"| AGW["agentgateway :3000"]
+ AGW -->|"stdio subprocess"| MCP["rustfs-mcp"]
+ MCP -->|"S3 API"| RustFS["RustFS :9000"]
+```
+
+网关把 `rustfs-mcp` 作为子进程拉起,并在其 stdio 传输与 3000 端口的 MCP Streamable HTTP 监听之间做转换。存储操作流经网关,因此网关的策略、限流和遥测同样作用于对象存储工具调用。
+
+:::note[为什么 stdio server 需要网关]
+
+stdio MCP server 只能被启动它的那台机器访问。agentgateway 补上了缺失的传输层——远程客户端通过 HTTP 连接,而 S3 凭证留在网关宿主机上。
+
+:::
+
+## 1. 构建 RustFS MCP server 镜像
+
+MCP server 在独立仓库中。从源码构建镜像:
+
+```bash
+git clone https://github.com/rustfs/mcp.git rustfs-mcp
+docker build -t rustfs/rustfs-mcp:latest rustfs-mcp
+```
+
+构建出的镜像以 stdio 方式运行 MCP server,并通过标准 `AWS_*` 环境变量连接任意 S3 兼容端点。
+
+## 2. 配置 agentgateway
+
+创建网关配置。target 以子进程方式启动 MCP 镜像;卷挂载为上传工具暴露宿主机目录,端点经由 Docker bridge 网关地址指向 RustFS:
+
+```yaml title="config.yaml"
+mcp:
+ port: 3000
+ targets:
+ - name: rustfs
+ stdio:
+ cmd: docker
+ args:
+ - run
+ - --rm
+ - -i
+ - -v
+ - /data/agentgateway/demo:/demo
+ - -e
+ - AWS_ACCESS_KEY_ID=
+ - -e
+ - AWS_SECRET_ACCESS_KEY=
+ - -e
+ - AWS_REGION=us-east-1
+ - -e
+ - AWS_ENDPOINT_URL=http://172.17.0.1:9000
+ - rustfs/rustfs-mcp:latest
+```
+
+:::note[MCP 容器内的端点寻址]
+
+MCP server 运行在容器里,RustFS 宿主机上的 `127.0.0.1:9000` 对它不可达。使用 Docker bridge 网关地址 `172.17.0.1:9000`(或共享网络别名)。如果 RustFS 本身也跑在自定义 bridge 网络的 Docker 里,Docker 会隔离不同 bridge——把两个容器接入同一网络并使用容器名。
+
+:::
+
+以配置内容启动网关:
+
+```bash
+agentgateway -c "$(cat config.yaml)"
+```
+
+日志会确认各监听器:3000 端口的 MCP bind、`http://localhost:15000/ui` 的管理 UI,以及 15020 的 stats 端点。
+
+
+
+## 3. 通过网关调用 RustFS 工具
+
+MCP inspector 可驱动网关做人工验证:
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp --method tools/list
+```
+
+```json
+"tools": ["create_bucket", "delete_bucket", "get_object", "list_buckets", "list_objects", "upload_file"]
+```
+
+通过网关创建桶并上传文件:
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name create_bucket \
+ --tool-arg bucket_name=agw-demo
+
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name upload_file \
+ --tool-arg local_file_path=/demo/hello.txt \
+ --tool-arg bucket_name=agw-demo --tool-arg object_key=hello.txt
+```
+
+```text
+✅ **File uploaded successfully!**
+```
+
+:::note[上传路径在 MCP server 一侧]
+
+`upload_file` 读取的是运行 MCP server 的进程所在文件系统中的 `local_file_path`——也就是容器内部。第 2 步的卷挂载 `-v /data/agentgateway/demo:/demo` 把宿主机目录暴露为容器内的 `/demo`,工具因此能读到文件。
+
+:::
+
+## 4. 在 RustFS 中确认对象
+
+经网关写入的对象和普通 S3 写入一样落桶。用 S3 API 确认,替换全部连接占位符:
+
+```bash
+aws s3api list-objects --bucket agw-demo \
+ --endpoint-url http://localhost:9000
+```
+
+```json
+{
+ "Contents": [
+ {
+ "Key": "hello.txt",
+ "Size": 39,
+ "StorageClass": "STANDARD"
+ }
+ ]
+}
+```
+
+再经网关读回,完成闭环:
+
+```bash
+npx @modelcontextprotocol/inspector --cli http://localhost:3000/mcp \
+ --method tools/call --tool-name get_object \
+ --tool-arg bucket_name=agw-demo --tool-arg object_key=hello.txt --tool-arg mode=read
+```
+
+ Content: hello from rustfs-mcp via agentgateway
+
+
+
+## 验证结果
+
+| 检查项 | 预期结果 |
+| --- | --- |
+| 经网关的 MCP 握手 | `serverInfo.name` 返回 `rustfs-mcp-server`,协议 `2025-03-26` |
+| `tools/list` | 六个存储工具全部联邦:`create_bucket`、`delete_bucket`、`get_object`、`list_buckets`、`list_objects`、`upload_file` |
+| 经网关 `create_bucket` | 桶出现在 RustFS |
+| 经网关 `upload_file` | 对象落桶;控制台与 S3 API 均可见 |
+| 经网关 `get_object` | 内容与上传文件逐字节一致 |
+| 网关管理 UI | 正确显示已配置的 MCP server 与端口 |
+
+## 故障排查
+
+### `Error: invalid config: invalid type: string "config.yaml"`
+
+config 参数接收的是配置内容而非路径。传文件内容:`agentgateway -c "$(cat config.yaml)"`。
+
+### MCP 工具超时或报连接错误
+
+MCP 容器到不了 RustFS 地址。容器内的 `127.0.0.1:9000` 是容器自身——使用 `172.17.0.1:9000`(Docker bridge 网关)或共享网络别名,见第 2 步。
+
+### `upload_file` 报本地文件不存在
+
+路径在 MCP server 容器内解析。用 `-v` 把宿主机目录挂进容器并引用挂载路径,见第 2 步。
+
+### `GET /mcp` 返回 `406 Not Acceptable`
+
+预期行为:Streamable HTTP 端点只接受带 `Accept: application/json, text/event-stream` 头的 `POST` 请求——请使用 inspector 等 MCP 客户端,不要用浏览器。
+
+## 下一步
+
+- 查阅 [RustFS MCP server](/developer/mcp) 参考了解完整工具集。
+- 使用[访问密钥管理](/security-compliance/iam/access-token)为网关身份创建专用凭证。
+- 按照 [agentgateway 文档](https://agentgateway.dev/docs/)在同一网关上使用认证策略、限流与 OpenTelemetry。
diff --git a/content/zh/developer/integration/ai/images/agentgateway-ui.png b/content/zh/developer/integration/ai/images/agentgateway-ui.png
new file mode 100644
index 00000000..865b4673
Binary files /dev/null and b/content/zh/developer/integration/ai/images/agentgateway-ui.png differ
diff --git a/content/zh/developer/integration/ai/images/rustfs-agentgateway-bucket.png b/content/zh/developer/integration/ai/images/rustfs-agentgateway-bucket.png
new file mode 100644
index 00000000..1f2fdb8b
Binary files /dev/null and b/content/zh/developer/integration/ai/images/rustfs-agentgateway-bucket.png differ
diff --git a/content/zh/developer/integration/ai/meta.json b/content/zh/developer/integration/ai/meta.json
index 4deb8701..fee6d822 100644
--- a/content/zh/developer/integration/ai/meta.json
+++ b/content/zh/developer/integration/ai/meta.json
@@ -8,6 +8,7 @@
"dify",
"ragflow",
"cocoindex",
- "feast"
+ "feast",
+ "agentgateway"
]
}
diff --git a/content/zh/developer/mcp.md b/content/zh/developer/mcp.md
index c236cff3..f2198cce 100644
--- a/content/zh/developer/mcp.md
+++ b/content/zh/developer/mcp.md
@@ -192,6 +192,8 @@ List the buckets in this RustFS instance.
Trae 使用 **Builder with MCP** 模式,调用 `list_buckets` 工具列出已配置 RustFS 实例中的所有存储桶。调用其他工具时同样如此。
+如果不想在本地运行该服务器,而是希望远程暴露,[agentgateway](integration/ai/agentgateway.md) 可以把 RustFS MCP server 作为 stdio target 联邦,并通过 HTTP 提供带认证和遥测的服务。
+
## 🛠️ 可用工具
MCP 服务器公开以下工具供 AI 助手使用: