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 — nous offrons 10M de tokens gratuits au démarrage. Dans le Dashboard, créez une clé avec le préfixe jg-.

Installation des paquets. Pour un endpoint custom compatible avec OpenAI, le SDK Vercel AI recommande le fournisseur @ai-sdk/openai-compatible :

npm install ai @ai-sdk/openai-compatible

Connexion minimale — créez une instance du fournisseur via createOpenAICompatible et appelez 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-votre-clé
});

const { text } = await generateText({
  model: gonka('MiniMaxAI/MiniMax-M2.7'),
  prompt: 'Explique ce qu'est un réseau d'inférence décentralisé',
});

console.log(text);

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

Alternative — le paquet @ai-sdk/openai avec la factory createOpenAI({ baseURL, apiKey }). Les deux méthodes fonctionnent ; pour les endpoints n'appartenant pas à OpenAI, la documentation du SDK AI recommande explicitement @ai-sdk/openai-compatible — il n'inclut pas les hypothèses spécifiques à OpenAI.

La fonctionnalité principale du Vercel AI SDK est le streaming de la réponse. La fonction streamText commence à streamer les tokens immédiatement, et le helper toUIMessageStreamResponse() renvoie le flux directement depuis le route handler dans Next.js App Router.

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

// autorisation de streaming jusqu'à 30 secondes
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: 'Tu es un assistant utile. Réponds de manière concise et pertinente.',
    messages: convertToModelMessages(messages),
    maxOutputTokens: 8192, // limite de sortie via Gateway
  });

  return result.toUIMessageStreamResponse();
}

Côté client, connectez le hook useChat depuis @ai-sdk/react — il gère lui-même les appels vers /api/chat et le rendu du flux de messages. Le backend communique alors avec Gonka, et non OpenAI.

Script sans UI (Node, itérateur asynchrone 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: 'Écris un haïku sur le calcul distribué',
});

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

Paramètres des modèles. Deux modèles sont disponibles via la Gateway, chacun avec une fenêtre de contexte de 200K tokens ; la limite de réponse (maxOutputTokens) va jusqu'à 8192 pour chacun :

• moonshotai/Kimi-K2.6 — par défaut (Kimi K2.6) ;
• MiniMaxAI/MiniMax-M2.7 (MiniMax M2.7).

Si maxOutputTokens n'est pas défini, la Gateway renverra par défaut jusqu'à 1500 tokens pour les requêtes non-streaming — il est préférable de spécifier explicitement cette valeur pour les chats en streaming.

Vercel AI SDK se situe généralement derrière une interface interactive — chat, agent, assistant d'application. Chaque message entraîne l'historique du dialogue, chaque étape d'un agent entraîne le contexte des outils. C'est pourquoi le coût réel se calcule non pas par requête, mais selon la charge en production. Comparons des scénarios typiques :

Le prix de JoinGonka est d'environ 0,003 $ par 1M de tokens en entrée, la sortie étant environ trois fois plus chère. Pour une application avec des milliers de requêtes par jour, cela représente la différence entre une facture de centaines de dollars et une facture de quelques centimes. Les 10M de tokens gratuits suffisent pour tester et déboguer entièrement un projet avant son passage en production.

Vercel AI SDK décrit les outils de manière déclarative via l'objet tools et le schéma zod. Kimi K2.6 prend en charge le function calling natif, permettant ainsi à l'AI SDK de recevoir des tool_calls structurés sans avoir à analyser les réponses textuelles. Le paramètre stopWhen: stepCountIs(n) autorise plusieurs étapes consécutives — le modèle appelle un outil, reçoit le résultat et continue.

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: 'Obtenir la météo dans la ville',
      inputSchema: z.object({ city: z.string() }),
      execute: async ({ city }) => ({ city, tempC: 17 }),
    }),
  },
  prompt: 'Quelle est la météo à Moscou ? Réponds en une seule phrase.',
});

console.log(text);

Le modèle appelle l'outil weather, reçoit le résultat et génère la réponse finale. Le cycle complet coûte environ $0.000048 via Gonka contre $0.03-0.10 chez Anthropic ou OpenAI. Pour les applications d'agents, où chaque requête utilisateur se déploie en 5-10 étapes, les économies en production se comptent en milliers de dollars par mois.

Si vous développez une application AI sur Python, consultez le guide sur LangChain — on y retrouve la même approche via la classe compatible OpenAI.