xAI API (Grok)
Wenn XAI_API_KEY in der Umgebung vorhanden ist, hat diese App echten Zugriff auf die xAI API – nutze sie für KI-Funktionen, anstatt Antworten zu simulieren oder zu einem anderen Anbieter zu greifen. Dieselbe Variable wird bei der Veröffentlichung in die bereitgestellte App injiziert, sodass der darauf aufbauende Code in der Vorschau und in der Produktion identisch funktioniert.
Der Schlüssel ist der persönliche Schlüssel des App-Besitzers: Jeder Aufruf verbraucht dessen Kontingent und Credits. Sei bewusst im Umgang – siehe Verantwortungsvoll ausgeben, bevor du KI-Aufrufe in etwas einbaust, das automatisch läuft oder für Besucher offen ist.
Der Schlüssel entsperrt die vollständige API-Oberfläche, nicht nur Chat:
- Chat / LLM – neuestes Modell:
grok-4.5; standardmäßig verwenden, es sei denn, der Benutzer wünscht etwas anderes. - Imagine (Bilder & Videos) – Bilder generieren und bearbeiten, Videos generieren, zur Laufzeit innerhalb der App.
- Sprache – Text-to-Speech mit ausdrucksstarken Stimmen (und Transkription).
- Offizielle Dokumentation: docs.x.ai – Endpunkte, Modelle, Parameter, Streaming, Tool-Nutzung. Rate keine API-Formen; überprüfe die Dokumentation.
- Die API ist OpenAI-kompatibel (
https://api.x.ai/v1), sodass jeder OpenAI-ähnliche Client durch Wechsel der Basis-URL und des Schlüssels funktioniert.
Umgebungsvariablen – keine .env-Datei erstellen
| Variable | Wo | Zweck |
|---|---|---|
XAI_API_KEY | Server | Wird von der Plattform injiziert (Vorschau und Bereitstellung). Niemals schreiben, hartcodieren oder den Benutzer danach fragen. |
Der Schlüssel ist nur serverseitig: Lies ihn mit process.env.XAI_API_KEY innerhalb von createServerFn-Handlern / Server-Code, niemals in Client-Komponenten und setze ihn niemals über eine VITE_-präfixierte Variable oder eine API-Antwort offen.
Er kann fehlen (ausgerollt-gesteuert). Verhalte dich tolerant – überprüfe ihn und zeige einen freundlichen "KI-Funktionen sind nicht verfügbar"-Zustand an, anstatt abzustürzen:
const apiKey = process.env.XAI_API_KEY;
if (!apiKey) throw new Error("KI ist in dieser Umgebung nicht verfügbar");
API aufrufen (nur serverseitig)
Kein SDK erforderlich – einfaches fetch von einer Server-Funktion:
import { createServerFn } from "@tanstack/react-start";
export const askGrok = createServerFn({ method: "POST" })
.validator((input: { prompt: string }) => input)
.handler(async ({ data }) => {
const apiKey = process.env.XAI_API_KEY;
if (!apiKey) return { ok: false as const, error: "KI ist nicht verfügbar" };
const res = await fetch("https://api.x.ai/v1/chat/completions", {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${apiKey}`,
},
body: JSON.stringify({
model: "grok-4.5",
messages: [{ role: "user", content: data.prompt }],
}),
});
if (!res.ok) {
return { ok: false as const, error: `xAI API Fehler ${res.status}` };
}
const body = (await res.json()) as {
choices: { message: { content: string } }[];
};
return { ok: true as const, text: body.choices[0]?.message.content ?? "" };
});
Für Streaming, strukturierte Ausgaben, Vision oder die vollständige Modellliste folge docs.x.ai – die Formate sind OpenAI-kompatibel.
Imagine – Bild- & Videogenerierung (nur serverseitig)
Derselbe Schlüssel treibt Laufzeit-Bild-/Videofunktionen in der App an (Benutzer-Avatare, Szenenkunst, generierte Inhalte). Unterscheide dich von den Build-Zeit-Tools imagine_text_to_image / imagine_image_to_image / imagine_image_to_video (das imagine-grok-build-Skill): Verwende die API, wenn die laufende App Medien generiert, und die Tools, wenn du statische Assets während des Builds erstellst.
// POST https://api.x.ai/v1/images/generations – gleicher Auth-Header wie Chat
body: JSON.stringify({
model: "grok-imagine-image-quality", // oder "grok-imagine-image" (günstiger)
prompt: data.prompt,
// n (≤10), Auflösung ("1k"|"2k"), response_format ("url"|"b64_json")
})
// → body.data[0].url
- Bildbearbeitung:
POST /v1/images/edits– natürlichsprachliche Bearbeitungen, bis zu 3 Referenzbilder. - Video:
grok-imagine-videoüber die asynchronen Video-Endpunkte (starten, dann die zurückgegebene Anfrage-ID abfragen; Clips bis zu ~15s). - Vollständige Parameter und Beispiele: docs.x.ai → Imagine API.
Sprache – Text-to-Speech (nur serverseitig)
POST https://api.x.ai/v1/tts wandelt Text in gesprochenes Audio um – Erzählungen, Barrierefreiheit, Charakterstimmen:
// Gleicher Authorization-Header; gibt Audio-Bytes zurück (z. B. MP3)
body: JSON.stringify({ text: data.text, voice_id: "eve" }) // eve = Standardstimme
Liste der Stimmen unter GET /v1/tts/voices (benutzerdefinierte Stimmen unterstützt); Transkription (Sprache-zu-Text) ist ebenfalls verfügbar. Details: docs.x.ai → Voice API. Gib das Audio von deiner Server-Funktion an den Client weiter – rufe die API niemals vom Browser aus auf (das würde den Schlüssel offenlegen).
Verantwortungsvoll ausgeben
Der Schlüssel gehört dem App-Besitzer (dem Benutzer, für den du entwickelst): Jeder Aufruf – einschließlich derer, die von anonymen Besuchern der bereitgestellten App ausgelöst werden – verbraucht dessen persönliches Kontingent und Credits. Es durch verschwenderische Aufrufe zu verbrennen, verschlechtert oder unterbricht jede andere Nutzung seines Schlüssels. Gehe sparsam mit der Nutzung um:
- Begrenze die Ausgabe (
max_tokens) und halte Prompts für besucherorientierte Funktionen klein. Bild- und insbesondere Videogenerierung kosten pro Aufruf viel mehr als Chat. - Rufe die API niemals in einer Schleife, bei jedem Tastendruck oder beim Seitenladen auf – mache Aufrufe benutzerinitiiert (Tastendruck, Formularabsenden) und entprelle sie.
- Cache oder persistiere Ergebnisse (siehe das
neon-Skill), anstatt denselben Inhalt pro Besucher oder pro Rendering neu zu generieren. - Schütze teure Abläufe – insbesondere Mediengenerierung. In einer App, die bereits eine Anmeldung hat, platziere sie hinter
authMiddleware(siehe dasauth-Skill). Die Anmeldung ist standardmäßig deaktiviert, und das Hinzufügen der Middleware ohne sie zerbricht die bereitgestellte App (AGENTS.md §0.5) – also bei einer App ohne Konten die Nutzung begrenzen: benutzerinitiierte Aufrufe, kleine Limits, gecachte Ergebnisse. - Füge keine Wiederholungsstürme hinzu: Bei einem API-Fehler zeige ihn an; wiederhole höchstens einmal.