Einen eigenen Cloud-Storage-Handler implementieren
Verwenden Sie den Filter chamevo_storage_handler, um Kunden-Uploads und druckfertige Dateien über die Implementierung von StorageHandlerInterface an einen beliebigen Cloud-Storage-Anbieter weiterzuleiten.
Aktualisiert am 9. Mai 20265 Min. Lesezeit
Standardmäßig speichert Chamevo alle Dateien im lokalen WordPress-Dateisystem unter wp-content/uploads/chamevo/. Mit dem Filter chamevo_storage_handler können Sie zwei Ordnertypen — Kunden-Uploads und generierte druckfertige Dateien — an einen externen Storage-Anbieter weiterleiten: Amazon S3, Hetzner Object Storage, Google Cloud Storage, Dropbox (programmatisch) oder jeden anderen Dienst mit einem PHP SDK.
Die integrierten Dropbox- und AWS S3-Lieferungseinstellungen decken die häufigsten Anwendungsfälle ohne Code ab. Verwenden Sie diese API, wenn Sie einen nicht integrierten Anbieter benötigen oder wenn Sie unterschiedliche Buckets, CDN-Konfigurationen oder eigene Geschäftslogik pro Ordnertyp brauchen.
Geltungsbereich
Nur zwei Ordnertypen können zu Cloud Storage weitergeleitet werden:
| Ordnertyp | Inhalt | Standard-lokaler Pfad |
|---|---|---|
uploads | Vom Kunden hochgeladene Dateien aus dem Frontend-Customizer (Bilder, PDFs, SVGs) | wp-content/uploads/chamevo/uploads/ |
print_files | Generierte druckfertige Exporte (PDF, PNG, SVG, ZIP) | wp-content/uploads/chamevo/print_files/ |
Alle anderen Ordner (_temp, fonts, 3d_models, patterns_svg usw.) verbleiben immer lokal und können nicht weitergeleitet werden.
Dateifluss
Ähnliche Artikel
Auf Customizer-Events per JavaScript reagierenLesen Sie den Live-Preis des Customizers aus und reagieren Sie mit der clientseitigen ChamevoJS-API per eigenem JavaScript auf Produkt-, Ansichts- und Elementänderungen.Den Chamevo MCP-Server einrichtenVerbinden Sie Claude und andere KI-Assistenten über den @chamevo/mcp-Server mit Ihrem Chamevo-Shop — ohne Installation, mit einem einzigen JSON-Block — und verwalten Sie Produkte, Bestellungen und druckfertige Dateien per Chat.Einen eigenen AI-Provider verwendenLeiten Sie Chamevos AI Tools mit toolspezifischen wp-config-Konstanten oder Filtern an Ihren eigenen Provider-Endpoint und API-Schlüssel weiter und umgehen Sie so den gehosteten Chamevo-Dienst und den Credit-Verbrauch.
Standardmäßig laufen Chamevos AI Tools über den gehosteten Chamevo-Dienst und verbrauchen KI-Credits. Sie können stattdessen jedes Tool auf Ihren eigenen AI-Provider verweisen. Wenn Sie das tun, ruft Chamevo Ihren Endpoint direkt auf — es überspringt den gehosteten Dienst, sendet keinen Chamevo-Lizenz-Header und verbraucht für dieses Tool keine Chamevo-Credits.
Sie können jedes Tool unabhängig weiterleiten. Senden Sie zum Beispiel Text-zu-Bild an Ihren eigenen Provider, während Upscaling und Hintergrundentfernung weiterhin über den gehosteten Dienst laufen.
AI Photo Styles können ebenfalls Ihren eigenen Provider nutzen, allerdings nur über Filter — dafür gibt es keine wp-config-Konstanten. Siehe [AI Photo Styles weiterleiten](#ai-photo-styles-weiterleiten).
## Bevor Sie beginnen
- Sie können `wp-config.php` auf Ihrem Server bearbeiten oder PHP-Filter in einem Plugin oder Theme hinzufügen.
- Sie haben eine Endpoint-URL und einen API-Schlüssel für jedes AI-Tool, das Sie weiterleiten möchten.
- Sie kennen das Request- und Response-Format Ihres Providers. Wenn es von Chamevos Standard abweicht, bilden Sie es mit den unten stehenden Request- und Response-Filtern ab.
Die AI Tools werden diesen kanonischen Schlüsseln zugeordnet:
| AI-Tool | Tool-Schlüssel | Konstanten-Infix |
|---------|----------|----------------|
| Bilder aus Text generieren | `text2image` | `TEXT2IMAGE` |
| Bilder hochskalieren | `upscale` | `UPSCALE` |
| Hintergründe entfernen | `remove_background` | `REMOVE_BACKGROUND` |
| AI Photo Styles | `image_filter` | — (nur Filter) |
## Ein Tool mit wp-config-Konstanten weiterleiten
Die einfachste Einrichtung verwendet Konstanten in `wp-config.php`.
1. Öffnen Sie `wp-config.php` im Stammverzeichnis Ihrer WordPress-Installation.
2. Definieren Sie über der Zeile `/* That's all, stop editing! */` den Endpoint und den Schlüssel für das Tool, das Sie weiterleiten möchten.
3. Speichern Sie die Datei.
```php
// Route text-to-image to your own provider.
define('CHAMEVO_AI_TEXT2IMAGE_ENDPOINT', 'https://api.example.com/v1/images');
define('CHAMEVO_AI_TEXT2IMAGE_KEY', 'sk-your-provider-key');
define('CHAMEVO_AI_TEXT2IMAGE_MODEL', 'my-image-model'); // optional
```
Sobald die Endpoint-Konstante einen Wert hat, befindet sich dieses Tool im **Custom-Modus**. Wenn ein Kunde es das nächste Mal verwendet, sendet Chamevo den Request direkt an Ihren Endpoint.
### Konstanten-Referenz
Ersetzen Sie `{TOOL}` durch `TEXT2IMAGE`, `UPSCALE` oder `REMOVE_BACKGROUND`.
| Konstante | Erforderlich | Zweck |
|----------|----------|---------|
| `CHAMEVO_AI_{TOOL}_ENDPOINT` | Ja | Vollständige Provider-URL. Ein nicht-leerer Wert aktiviert den Custom-Modus. |
| `CHAMEVO_AI_{TOOL}_KEY` | Empfohlen | API-Schlüssel. Wird als `Authorization: Bearer …` gesendet. |
| `CHAMEVO_AI_{TOOL}_MODEL` | Nein | Modell-Identifier, dem Request-Body als `model` hinzugefügt. |
## Was der Custom-Modus ändert
Im Custom-Modus geht Chamevo wie folgt vor:
- Sendet den Request direkt an Ihren Endpoint, nicht an den gehosteten Chamevo-Dienst.
- Verwendet `POST` mit `Authorization: Bearer {Ihr Schlüssel}`.
- Sendet **nicht** den Chamevo-Lizenz-Header (`X_API_TOKEN`).
- Verbraucht für dieses Tool **keine** Chamevo-KI-Credits.
Standardmäßig sendet Chamevo seinen eigenen Request-Body und erwartet seine eigene Response-Form.
**Standard-Request-Body pro Tool** (plus `model`, wenn die `_MODEL`-Konstante gesetzt ist):
| Tool | Standard-Body |
|------|--------------|
| `text2image` | `{ "prompt": "..." }` |
| `upscale` | `{ "image_url": "...", "scale": 2 }` |
| `remove_background` | `{ "image_url": "..." }` |
**Erwartete Response-Form:**
```json
{ "status": "success", "data": { "output": "https://your-cdn.com/result.png" } }
```
`output` kann eine einzelne URL, ein Array von URLs oder eine `data:image/…;base64,…`-URI sein.
Wenn Ihr Provider diesen Body bereits akzeptiert und diese Form zurückgibt, genügen die Konstanten allein. Andernfalls bilden Sie die Formen mit den unten stehenden Filtern ab.
### Einstellungen, die der Custom-Modus ignoriert
Die Text-zu-Bild-Einstellungen unter **Chamevo → Settings → General → AI Services** gelten nur für den gehosteten Dienst. Im Custom-Modus sendet Chamevo nicht:
- das Modell und die Auflösung aus **Image Generation Model & Resolution**
- die Bildanzahl aus **Images per Generation**
Das entscheidet stattdessen Ihr Provider. Legen Sie das Modell mit `CHAMEVO_AI_TEXT2IMAGE_MODEL` fest und Größe sowie Bildanzahl in `chamevo_ai_text2image_request_body` (zum Beispiel `n` und `size`). Geben Sie in `output` ein Array von URLs zurück, damit Kunden mehrere Bilder erhalten.
Dasselbe gilt für AI Photo Styles: Das pro Style gewählte **Image model** wird nicht an einen eigenen Provider gesendet. In diesen Einstellungen angezeigte Credits werden im Custom-Modus nicht berechnet.
## Einen Provider mit abweichendem Schema abbilden
Die meisten Provider verwenden ihre eigenen Request- und Response-Formate. Verwenden Sie die Request- und Response-Filter zur Übersetzung. `{tool}` ist `text2image`, `upscale` oder `remove_background`.
Dieses Beispiel passt Text-zu-Bild an einen Image-Endpoint im OpenAI-Stil an:
```php
// Reshape the request body to the provider's schema.
add_filter('chamevo_ai_text2image_request_body', function($body, $context) {
return [
'model' => $context['config']['model'] ?: 'gpt-image-1',
'prompt' => $context['prompt'],
'n' => 1,
'size' => '1024x1024',
];
}, 10, 2);
// Normalize the provider response back into Chamevo's shape.
add_filter('chamevo_ai_text2image_response', function($normalized, $raw, $config) {
return [
'status' => 'success',
'data' => ['output' => $raw['data'][0]['url']],
];
}, 10, 3);
```
`$context` enthält die Tool-Eingaben — `prompt` für `text2image` und `image_url` (plus `scale` für `upscale`) für die Bild-Tools — sowie die aufgelöste `config`.
### Konfiguration zur Laufzeit statt in wp-config festlegen
Wenn Sie `wp-config.php` nicht bearbeiten können oder den Provider dynamisch wählen möchten, verwenden Sie den Config-Filter anstelle von Konstanten:
```php
add_filter('chamevo_ai_upscale_config', function($config, $tool) {
$config['endpoint'] = 'https://api.example.com/v1/upscale';
$config['api_key'] = get_option('my_upscale_key');
return $config;
}, 10, 2);
```
### Asynchrone Provider aufrufen
Für Provider, die einen Job erstellen und Polling erfordern (oder die ein SDK benötigen), schließen Sie den integrierten HTTP-Aufruf mit dem `pre`-Filter kurz. Geben Sie Chamevos Response-Form zurück, und der integrierte Request wird vollständig übersprungen:
```php
add_filter('chamevo_ai_text2image_pre', function($result, $context) {
$url = my_provider_create_and_poll($context['prompt']);
return ['status' => 'success', 'data' => ['output' => $url]];
}, 10, 2);
```
Die vollständige Filter-Familie ist in der [WordPress-Hooks und Filter Referenz](/kb/wordpress/developers/wordpress-hooks) dokumentiert.
## AI Photo Styles weiterleiten
[AI Photo Styles](/kb/wordpress/ai-tools/photo-styles) verwenden den Tool-Schlüssel `image_filter`. Es gibt keine `CHAMEVO_AI_IMAGE_FILTER_*`-Konstanten, legen Sie den Endpoint daher mit dem Config-Filter fest:
```php
add_filter('chamevo_ai_image_filter_config', function($config, $tool) {
$config['endpoint'] = 'https://api.example.com/v1/images/edits';
$config['api_key'] = MY_IMAGE_EDIT_KEY; // sent as Authorization: Bearer …
return $config;
}, 10, 2);
```
Es gelten dieselben Filter `pre`, `request_body`, `request_headers` und `response`, mit `image_filter` als `{tool}`.
**Standard-Request-Body:**
```json
{ "image": "https://… or data:image/jpeg;base64,…", "prompt": "<the style's prompt>" }
```
`$context` enthält `image`, `prompt` und die aufgelöste `config`. Das Bild ist eine öffentliche URL oder eine Inline-JPEG-Data-URI (längste Kante 2048 px), wenn Ihre Website nicht aus dem Internet erreichbar ist. Der Prompt stammt aus dem Style auf Ihrem Server — der Browser des Kunden sieht ihn nie.
Geben Sie Chamevos Response-Form mit einem Ergebnisbild in `output` zurück (eine URL oder eine `data:image/…;base64,…`-URI). Chamevo speichert das Ergebnis auf Ihrem Server und platziert es auf dem Canvas.
Styles benötigen weiterhin aktivierte **AI Photo Styles** unter **Settings → General → AI Services** sowie einen Prompt. Die Schaltfläche **Try** auf dem Bildschirm der AI Photo Styles nutzt dieselbe Route.
## Überprüfen Sie Ihr Setup
- Öffnen Sie ein Produkt im Customizer und führen Sie das AI-Tool aus, das Sie weitergeleitet haben.
- Vergewissern Sie sich, dass das Ergebnisbild zurückkommt und dem Canvas hinzugefügt wird.
- Überprüfen Sie, dass sich Ihr Chamevo-KI-Credit-Guthaben für dieses Tool nicht ändert — Credits werden nur im gehosteten Modus verbraucht.
- Wenn ein Request fehlschlägt, aktivieren Sie das Debug-Logging und suchen Sie nach einem Eintrag `Custom AI provider request failed` mit dem Tool und dem Endpoint.
## Fehlerbehebung
- **Das Tool verwendet weiterhin das gehostete Chamevo und verbraucht Credits** — Die Endpoint-Konstante ist leer oder falsch benannt. Der Name muss genau `CHAMEVO_AI_{TOOL}_ENDPOINT` lauten, mit dem Tool in Großbuchstaben (`TEXT2IMAGE`, `UPSCALE`, `REMOVE_BACKGROUND`), und er muss definiert sein, bevor WordPress das Plugin lädt.
- **Der Provider gibt 401 oder 403 zurück** — Der Schlüssel fehlt oder ist falsch. Überprüfen Sie die `_KEY`-Konstante oder setzen Sie einen benutzerdefinierten Auth-Header mit `chamevo_ai_{tool}_request_headers`.
- **Der Provider lehnt den Request-Body ab** — Sein Schema weicht von Chamevos Standard ab. Bilden Sie den Body mit `chamevo_ai_{tool}_request_body` ab.
- **Das Bild erscheint nie, obwohl der Provider antwortet** — Die Response-Form stimmt nicht überein. Bilden Sie sie mit `chamevo_ai_{tool}_response` auf `{ "status": "success", "data": { "output": "<url>" } }` ab.
- **Nur ein Tool wird korrekt weitergeleitet** — Jedes Tool wird separat konfiguriert. Definieren Sie Konstanten (oder Filter) für jedes Tool, das Sie weiterleiten möchten.
- **Meine Einstellungen für Modell oder Bildanzahl haben keine Wirkung** — Im Custom-Modus werden die Einstellungen **Image Generation Model & Resolution** und **Images per Generation** nicht gesendet. Legen Sie sie stattdessen in `chamevo_ai_text2image_request_body` fest.
- **AI Photo Styles verbrauchen weiterhin Chamevo-Credits** — `CHAMEVO_AI_IMAGE_FILTER_*`-Konstanten existieren nicht. Verwenden Sie den Filter `chamevo_ai_image_filter_config`.
## Nächste Schritte
- [WordPress-Hooks und Filter Referenz](/kb/wordpress/developers/wordpress-hooks) für die vollständigen AI-Filter-Signaturen.
- [AI Tools – Überblick und Credit-Verbrauch](/kb/wordpress/ai-tools/overview), um zu sehen, welche Tools und Credits im gehosteten Modus gelten.
---
## FAQ
**F: Verhindert die Verwendung eines eigenen AI-Providers, dass Chamevo Credits berechnet?**
A: Ja. Wenn sich ein Tool im Custom-Modus befindet, ruft Chamevo Ihren Endpoint direkt auf und verbraucht für dieses Tool keine Chamevo-KI-Credits.
**F: Kann ich nur ein AI-Tool weiterleiten und die anderen gehostet lassen?**
A: Ja. Jedes Tool wird unabhängig konfiguriert. Definieren Sie Konstanten oder Filter nur für die Tools, die Sie umleiten möchten; der Rest verwendet weiterhin den gehosteten Chamevo-Dienst.
**F: Mein Provider verwendet ein anderes Request-Format. Funktioniert es trotzdem?**
A: Ja, mit einer kleinen Abbildung. Verwenden Sie die Filter `chamevo_ai_{tool}_request_body` und `chamevo_ai_{tool}_response`, um zwischen dem Format Ihres Providers und Chamevos erwarteter Form zu übersetzen.
**F: Können AI Photo Styles meinen eigenen Provider nutzen?**
A: Ja, aber nur über Filter. Geben Sie einen Endpoint aus `chamevo_ai_image_filter_config` zurück und bilden Sie bei Bedarf den Body `{ image, prompt }` mit `chamevo_ai_image_filter_request_body` ab.
**F: Gilt meine Einstellung Images per Generation auch für meinen eigenen Provider?**
A: Nein. Modell, Auflösung und Bildanzahl aus den AI-Services-Einstellungen gelten nur für den gehosteten Dienst. Ihr Provider legt sie fest, zum Beispiel über den Request-Body-Filter.