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 3M jetons gratuits au départ. Créez une clé avec le préfixe jg- dans le Dashboard.

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

npm install ai @ai-sdk/openai-compatible

Connexion minimale — créez une instance du provider 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: 'Expliquez 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. Conservez la clé dans une variable d'environnement GONKA_API_KEY (par exemple dans .env.local) et non dans le code.

Alternative — le package @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 @ai-sdk/openai-compatible — il n'inclut pas d'hypothèses spécifiques à OpenAI inutiles.

La fonctionnalité principale du SDK Vercel AI est la diffusion en continu (streaming) de la réponse. La fonction streamText commence à streamer les jetons immédiatement, et le helper toUIMessageStreamResponse() renvoie le flux prêt à l'emploi 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,
});

// on autorise un 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 précise.',
    messages: convertToModelMessages(messages),
    maxOutputTokens: 8192, // limite de sortie via Gateway
  });

  return result.toUIMessageStreamResponse();
}

Côté client, connectez le hook useChat de @ai-sdk/react — il appelle lui-même /api/chat et affiche le flux de messages. Le backend communique alors avec Gonka, et non avec OpenAI.

Script sans UI (Node, async-iterator 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. Trois modèles sont disponibles via Gateway : contexte de 200K jetons pour MiniMax M2.7, 380K pour DeepSeek V4 Flash et 390K pour GLM-5.3 Flash ; la limite de réponse (maxOutputTokens) est de 8192 pour MiniMax M2.7 et GLM-5.3 Flash, et 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 raisonnement — réfléchit avant de répondre).

Si maxOutputTokens n'est pas défini, pour une requête non-stream, le Gateway retournera par défaut jusqu'à 1500 jetons — pour les chats en streaming, il est préférable de spécifier 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.0069 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.

Vercel AI SDK décrit les outils de manière déclarative via l'objet tools et le schéma zod. Les modèles du réseau prennent en charge l'appel de fonction natif, donc l'AI SDK reçoit des tool_calls structurés sans avoir à analyser les réponses textuelles. Le paramètre stopWhen: stepCountIs(n) permet plusieurs étapes consécutives — le modèle appelle l'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: 'Connaître la météo dans une ville',
      inputSchema: z.object({ city: z.string() }),
      execute: async ({ city }) => ({ city, tempC: 17 }),
    }),
  },
  prompt: 'Quel temps fait-il à Moscou ? Réponds en une seule phrase.',
});

console.log(text);

Le modèle appelle l'outil weather, reçoit le résultat et formule 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 demande utilisateur se déploie en 5-10 étapes, les économies en production se chiffrent en milliers de dollars par mois.

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