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 10 millions de jetons gratuits au démarrage. Dans le tableau de bord, créez une clé avec le préfixe jg-.

Installation des paquets. Pour un point de terminaison personnalisé compatible OpenAI, Vercel AI SDK recommande le fournisseur @ai-sdk/openai-compatible :

npm install ai @ai-sdk/openai-compatible

Connexion minimale — nous créons une instance de fournisseur via createOpenAICompatible et appelons 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('Qwen/Qwen3-235B-A22B-Instruct-2507-FP8'),
  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. Stockez 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 fabrique createOpenAI({ baseURL, apiKey }). Les deux méthodes fonctionnent ; pour les points de terminaison n'appartenant pas à OpenAI, la documentation AI SDK recommande explicitement @ai-sdk/openai-compatible — il n'entraîne pas d'hypothèses spécifiques à OpenAI inutiles.

La principale caractéristique de Vercel AI SDK est la diffusion en continu de la réponse. La fonction streamText commence à diffuser les jetons immédiatement, et l'aide toUIMessageStreamResponse() renvoie le flux prêt directement depuis le gestionnaire de route dans Next.js App Router.

Gestionnaire de 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('Qwen/Qwen3-235B-A22B-Instruct-2507-FP8'),
    system: 'Vous êtes un assistant utile. Répondez de manière courte et concise.',
    messages: convertToModelMessages(messages),
    maxOutputTokens: 8192, // plafond de Qwen3-235B via Gateway
  });

  return result.toUIMessageStreamResponse();
}

Côté client, connectez le hook useChat de @ai-sdk/react — il se connecte à /api/chat et rend le flux de messages. Le backend interroge 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('Qwen/Qwen3-235B-A22B-Instruct-2507-FP8'),
  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 la passerelle, tous avec une fenêtre contextuelle de 128K jetons ; la limite de réponse (maxOutputTokens) diffère :

• Qwen/Qwen3-235B-A22B-Instruct-2507-FP8 — par défaut, jusqu'à 8192 jetons de sortie ;
• moonshotai/Kimi-K2.6 — jusqu'à 3072 (Kimi K2.6) ;
• MiniMaxAI/MiniMax-M2.7 — jusqu'à 4096 (MiniMax M2.7).

Si maxOutputTokens n'est pas spécifié, pour une requête non-stream Gateway renverra 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 situe 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 — le contexte des outils. Par conséquent, le coût réel n'est pas calculé par requête unique, mais par la charge de production. Comparons les scénarios typiques :

Le prix JoinGonka est d'environ 0,0005 $ 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 10M de jetons gratuits sont suffisants pour exécuter et déboguer complètement un projet avant sa mise en production.

Vercel AI SDK décrit les outils de manière déclarative via un objet tools et un schéma zod. Qwen3-235B prend en charge l'appel de fonction natif, de sorte que AI SDK reçoit des tool_calls structurés sans analyser les réponses textuelles. Le paramètre stopWhen: stepCountIs(n) autorise plusieurs étapes consécutives — le modèle appelle l'outil, obtient 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('Qwen/Qwen3-235B-A22B-Instruct-2507-FP8'),
  stopWhen: stepCountIs(5),
  tools: {
    weather: tool({
      description: 'Obtenir la météo dans une ville',
      inputSchema: z.object({ city: z.string() }),
      execute: async ({ city }) => ({ city, tempC: 17 }),
    }),
  },
  prompt: 'Quelle est la météo à Moscou ? Répondez en une seule phrase.',
});

console.log(text);

Le modèle appelle l'outil weather, obtient le résultat et formule la réponse finale. Le cycle complet coûte environ 0,00001 $ via Gonka contre 0,03 à 0,10 $ chez Anthropic ou OpenAI. Pour les applications d'agent, où chaque requête utilisateur se décompose en 5 à 10 étapes, les économies en production se chiffrent en milliers de dollars par mois.

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