Vercel AI SDK + Gonka AI – KI-Anwendungen mit TypeScript für kleines Geld

JoinGonka API-Schlüssel: Registriere dich auf gate.joingonka.ai/register — zum Start gibt es 3M kostenlose Token. Erstelle im Dashboard einen Schlüssel mit dem Präfix jg-.

Pakete installieren. Für einen eigenen OpenAI-kompatiblen Endpunkt empfiehlt das Vercel AI SDK den Provider @ai-sdk/openai-compatible:

npm install ai @ai-sdk/openai-compatible

Minimale Anbindung — wir erzeugen eine Provider-Instanz über createOpenAICompatible und rufen generateText auf:

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText } from 'ai';

const gonka = createOpenAICompatible({
  name: 'gonka',
  baseURL: 'https://gate.joingonka.ai/v1',
  apiKey: process.env.GONKA_API_KEY, // jg-your-key
});

const { text } = await generateText({
  model: gonka('MiniMaxAI/MiniMax-M2.7'),
  prompt: 'Explain what a decentralized inference network is',
});

console.log(text);

Der Parameter apiKey fügt automatisch den Header Authorization: Bearer jg-your-key hinzu — eine separate Konfiguration ist nicht nötig. Bewahre den Schlüssel in der Umgebungsvariable GONKA_API_KEY auf (zum Beispiel in .env.local) und nicht im Code.

Alternative — das Paket @ai-sdk/openai mit der Factory createOpenAI({ baseURL, apiKey }). Beide Wege funktionieren; für Endpunkte, die nicht zu OpenAI gehören, empfiehlt die AI SDK-Dokumentation genau @ai-sdk/openai-compatible — es schleppt keine überflüssigen OpenAI-spezifischen Annahmen mit.

Das Highlight des Vercel AI SDK ist die Streaming-Ausgabe der Antwort. Die Funktion streamText beginnt sofort mit dem Streaming der Token, und der Helper toUIMessageStreamResponse() liefert den fertigen Stream direkt aus dem Route Handler im Next.js App Router.

Server-Handler app/api/chat/route.ts:

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { streamText, convertToModelMessages, type UIMessage } from 'ai';

const gonka = createOpenAICompatible({
  name: 'gonka',
  baseURL: 'https://gate.joingonka.ai/v1',
  apiKey: process.env.GONKA_API_KEY,
});

// allow streaming for up to 30 seconds
export const maxDuration = 30;

export async function POST(req: Request) {
  const { messages }: { messages: UIMessage[] } = await req.json();

  const result = streamText({
    model: gonka('MiniMaxAI/MiniMax-M2.7'),
    system: 'You are a helpful assistant. Answer briefly and to the point.',
    messages: convertToModelMessages(messages),
    maxOutputTokens: 8192, // Gateway output cap
  });

  return result.toUIMessageStreamResponse();
}

Binde auf der Client-Seite den Hook useChat aus @ai-sdk/react ein — er wendet sich selbst an /api/chat und rendert den Nachrichtenstrom. Das Backend geht dabei zu Gonka und nicht zu OpenAI.

Skript ohne UI (Node, Async-Iterator über den Stream):

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { streamText } from 'ai';

const gonka = createOpenAICompatible({
  name: 'gonka',
  baseURL: 'https://gate.joingonka.ai/v1',
  apiKey: process.env.GONKA_API_KEY,
});

const result = streamText({
  model: gonka('MiniMaxAI/MiniMax-M2.7'),
  prompt: 'Write a haiku about distributed computing',
});

for await (const chunk of result.textStream) {
  process.stdout.write(chunk);
}

Modellparameter. Über das Gateway stehen drei Modelle zur Verfügung: Kontext von 180K Token bei MiniMax M2.7, 380K bei DeepSeek V4 Flash und 390K bei GLM-5.3 Flash; das Antwort-Limit (maxOutputTokens) liegt bei 8192 bei MiniMax M2.7 und GLM-5.3 Flash, bei 32768 bei DeepSeek V4 Flash:

• MiniMaxAI/MiniMax-M2.7 — Standard (MiniMax M2.7);
• deepseek-ai/DeepSeek-V4-Flash-0731 (DeepSeek V4 Flash, Kontext 380K);
• zai-org/GLM-5.3-Flash (GLM-5.3 Flash, Reasoning-Modell — denkt vor der Antwort nach).

Wenn maxOutputTokens nicht gesetzt ist, liefert das Gateway bei einer Non-Stream-Anfrage standardmäßig bis zu 1500 Token — bei Streaming-Chats gibst du den Wert besser explizit an.

Das Vercel AI SDK befindet sich normalerweise hinter einem interaktiven Interface — Chat, Agent, Assistent in der Anwendung. Jede Nachricht zieht eine Dialoghistorie nach sich, jeder Agent-Schritt den Tool-Kontext. Daher werden die tatsächlichen Kosten nicht pro Anfrage, sondern nach der Produktionslast berechnet. Vergleichen wir typische Szenarien:

Der Preis von JoinGonka liegt bei etwa $0.0062 pro 1M Input-Token, die Ausgabe ist etwa dreimal teurer. Für eine Anwendung mit Tausenden von Anfragen pro Tag ist dies der Unterschied zwischen einer Rechnung über Hunderte von Dollar und einer Rechnung im Cent-Bereich. Die kostenlosen 3M Token reichen aus, um die ersten Projektanfragen durchzuführen.

Das Vercel AI SDK beschreibt Tools deklarativ über das tools-Objekt und das zod-Schema. Die Modelle im Netzwerk unterstützen natives Function Calling, sodass das AI SDK strukturierte tool_calls erhält, ohne Textantworten parsen zu müssen. Der Parameter stopWhen: stepCountIs(n) erlaubt mehrere aufeinanderfolgende Schritte — das Modell ruft ein Tool auf, erhält das Ergebnis und macht weiter.

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText, tool, stepCountIs } from 'ai';
import { z } from 'zod';

const gonka = createOpenAICompatible({
  name: 'gonka',
  baseURL: 'https://gate.joingonka.ai/v1',
  apiKey: process.env.GONKA_API_KEY,
});

const { text } = await generateText({
  model: gonka('MiniMaxAI/MiniMax-M2.7'),
  stopWhen: stepCountIs(5),
  tools: {
    weather: tool({
      description: 'Get the weather in a city',
      inputSchema: z.object({ city: z.string() }),
      execute: async ({ city }) => ({ city, tempC: 17 }),
    }),
  },
  prompt: 'What is the weather in Moscow? Answer in one sentence.',
});

console.log(text);

Das Modell ruft das Tool weather auf, erhält das Ergebnis und formuliert die finale Antwort. Der gesamte Zyklus kostet über Gonka rund $0.000048 gegenüber $0.03-0.10 bei Anthropic oder OpenAI. Bei Agenten-Anwendungen, in denen jede Nutzeranfrage in 5-10 Schritte aufgefächert wird, summiert sich die Ersparnis im Produktivbetrieb auf Tausende Dollar pro Monat.

Wenn Sie eine KI-Anwendung in Python bauen, werfen Sie einen Blick auf den LangChain-Guide — dort gilt derselbe Ansatz über die OpenAI-kompatible Klasse.