Vercel AI SDK + Gonka AI — Applications IA en TypeScript pour une bouchée de pain

Clé API JoinGonka : inscrivez-vous sur gate.joingonka.ai/register — pour commencer, nous offrons 3M tokens gratuits. Dans le Dashboard, créez une clé avec le préfixe jg-.

Installation des paquets. Pour un endpoint personnalisé compatible OpenAI, le Vercel AI SDK recommande le provider @ai-sdk/openai-compatible :

npm install ai @ai-sdk/openai-compatible

Connexion minimale — on crée une instance du provider via createOpenAICompatible et on appelle generateText :

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);

Le paramètre apiKey ajoute automatiquement l'en-tête Authorization: Bearer jg-your-key — aucune configuration supplémentaire n'est nécessaire. Gardez la clé dans une variable d'environnement GONKA_API_KEY (par exemple dans .env.local), et non dans le code.

Alternative — le paquet @ai-sdk/openai avec la factory createOpenAI({ baseURL, apiKey }). Les deux méthodes fonctionnent ; pour les endpoints qui n'appartiennent pas à OpenAI, la documentation du AI SDK conseille précisément @ai-sdk/openai-compatible — il n'entraîne aucune hypothèse spécifique à OpenAI superflue.

Le point fort du Vercel AI SDK, c'est la diffusion en streaming de la réponse. La fonction streamText commence à streamer les tokens immédiatement, et le helper toUIMessageStreamResponse() renvoie un flux prêt à l'emploi directement depuis le route handler dans le Next.js App Router.

Le handler côté serveur 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();
}

Côté client, branchez le hook useChat de @ai-sdk/react — il s'adresse tout seul à /api/chat et affiche le flux de messages. Le backend, lui, passe par Gonka et non par OpenAI.

Script sans UI (Node, itérateur async sur le flux) :

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);
}

Paramètres des modèles. Trois modèles sont disponibles via le Gateway : un contexte de 180K tokens pour MiniMax M2.7, 380K pour DeepSeek V4 Flash et 390K pour GLM-5.3 Flash ; le plafond de réponse (maxOutputTokens) est de 8192 pour MiniMax M2.7 et GLM-5.3 Flash, et de 32768 pour DeepSeek V4 Flash :

• MiniMaxAI/MiniMax-M2.7 — par défaut (MiniMax M2.7) ;
• deepseek-ai/DeepSeek-V4-Flash-0731 (DeepSeek V4 Flash, contexte 380K) ;
• zai-org/GLM-5.3-Flash (GLM-5.3 Flash, modèle de reasoning — il raisonne avant de répondre).

Si maxOutputTokens n'est pas défini, pour une requête non-stream le Gateway renvoie par défaut jusqu'à 1500 tokens — pour les chats en streaming, mieux vaut indiquer la valeur explicitement.

Vercel AI SDK se trouve généralement derrière une interface interactive — chat, agent, assistant dans une application. Chaque message entraîne l'historique du dialogue, chaque étape de l'agent entraîne le contexte des outils. Par conséquent, le coût réel n'est pas calculé par requête unique, mais par charge de production. Comparons les scénarios typiques :

Le prix de JoinGonka est d'environ $0.0062 pour 1M de jetons en entrée, la sortie est environ trois fois plus chère. Pour une application avec des milliers de requêtes par jour, c'est la différence entre une facture de centaines de dollars et une facture de quelques centimes. Les 3M jetons gratuits suffisent pour lancer les premières requêtes du projet.

Le SDK Vercel AI décrit les outils de manière déclarative via un objet tools et un schéma zod. Les modèles du réseau prennent en charge le function calling natif, donc le SDK AI reçoit des tool_calls structurés sans parser les réponses textuelles. Le paramètre stopWhen: stepCountIs(n) autorise plusieurs étapes consécutives — le modèle appelle un outil, récupère le résultat et poursuit.

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);

Le modèle appelle l'outil weather, récupère le résultat et formule la réponse finale. Tout le cycle coûte environ 0,000048 $ via Gonka, contre 0,03 à 0,10 $ chez Anthropic ou OpenAI. Pour les applications agentiques, où chaque requête utilisateur se déploie en 5 à 10 étapes, l'économie en production se chiffre en milliers de dollars par mois.

Si vous développez une application IA en Python, consultez le guide LangChain — la même approche y est présentée via une classe compatible OpenAI.