Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Eerste aanroep en streaming in TypeScript

Les 9 van 14 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Uw eerste verzoek verzenden
  2. Streaming
  3. Gesprekken met meerdere beurten
  4. Generatie afstemmen en fouten afhandelen
  5. Belangrijkste punten

Les bijgewerkt op 3 november 2026 na het compileren van voorbeelden in strikte modus met SDK @mistralai/mistralai 3.5.0 en TypeScript 7.0.2. De SDK typeert content als string | ContentChunk[]: gesprekken met meerdere beurten en streaming-lussen compileerden niet zonder een typeof content === 'string'-controle. Het configuratievoorbeeld combineerde eerder temperature en topP, wat volgens de API-documentatie niet gelijktijdig gewijzigd moet worden. Foutafhandeling gebruikt nu de MistralError-klasse van de SDK, en de Express-route valideert de vraag voordat de API wordt aangeroepen. Bronnen: Mistral TypeScript SDK (README) · chat completion parameters.

Uw eerste verzoek verzenden

Nu de SDK is geïnstalleerd, gaan we aan de slag. De methode chat.complete() van de TypeScript SDK is het exacte equivalent van die in de Python SDK: dezelfde parameters, dezelfde responsstructuur, afgezien van naamgevingsconventies. Als u de Python-lessen heeft gevolgd, bevindt u zich op bekend terrein; alleen de asynchrone syntaxis van JavaScript is nieuw.

import 'dotenv/config';
import { Mistral } from '@mistralai/mistralai';

const client = new Mistral({
  apiKey: process.env.MISTRAL_API_KEY,
});

async function main() {
  const response = await client.chat.complete({
    model: 'mistral-small-latest',
    messages: [
      {
        role: 'user',
        content: 'Explain the concept of a closure in JavaScript in three sentences.',
      },
    ],
  });

  console.log(response.choices[0]?.message?.content);
}

main();

De vraagtekens in response.choices[0]?.message?.content zijn er niet voor niets: in de SDK-types zijn message en content optioneel, en bestaat choices[0] niet als de lijst leeg terugkomt. Veilige toegang geeft undefined terug in plaats van een uitzondering te genereren. Merk ook op dat content niet altijd een string is: de SDK typeert dit als string | ContentChunk[] omdat een respons kan binnenkomen als een lijst fragmenten (tekst, thinking-redenering, referenties, enz.).

De respons begrijpen

De responsstructuur is identiek aan die van de Python SDK. Het parseren ervan helpt u te begrijpen waarvoor u betaalt en waarom een respons stopt. Het volgende voorbeeld haalt de tekst, de stopreden en het aantal tokens één voor één op; als u dit uittypt, ziet u dat uw editor elk veld suggereert, wat bewijst dat de typering zijn werk doet.

async function analyserReponse() {
  const response = await client.chat.complete({
    model: 'mistral-small-latest',
    messages: [
      { role: 'user', content: 'What is the capital of France?' },
    ],
    maxTokens: 100,
  });

  // Response text
  const texte = response.choices[0]?.message?.content;

  // Stop reason
  const finRaison = response.choices[0]?.finishReason;

  // Token statistics
  const tokensEntree = response.usage?.promptTokens;
  const tokensSortie = response.usage?.completionTokens;

  console.log(`Response: ${texte}`);
  console.log(`Tokens: ${tokensEntree} input + ${tokensSortie} output`);
  console.log(`Stop: ${finRaison}`);
}

Let op de hoofdlettergebruik: waar Python max_tokens, finish_reason en prompt_tokens blootlegt, gebruikt TypeScript maxTokens, finishReason en promptTokens. Dit is de nummer één fout bij het handmatig overzetten van een Python-voorbeeld – en de compiler zal dit onmiddellijk signaleren.

Streaming

Streaming is essentieel voor webinterfaces: zonder zit de gebruiker enkele seconden naar een bevroren scherm te staren; met streaming verschijnt de tekst woord voor woord en stort de waargenomen latentie in. De TypeScript SDK stelt de stream bloot als een asynchrone generator, die u itereren met for await...of:

async function streamReponse() {
  const stream = await client.chat.stream({
    model: 'mistral-small-latest',
    messages: [
      {
        role: 'user',
        content: 'Describe the five main design patterns in JavaScript.',
      },
    ],
  });

  for await (const chunk of stream) {
    const content = chunk.data.choices[0]?.delta.content;
    if (typeof content === 'string') {
      process.stdout.write(content);
    }
  }
  console.log();
}

Twee details verdienen uw aandacht. De inhoud bevindt zich in chunk.data, niet direct in chunk: dit is de event-wrapper van de SDK sinds versie 1.0. En de typeof content === 'string'-controle filtert zowel fragmenten zonder inhoud (die uw uitvoer zouden vervuilen met undefined) als inhoud die uit een lijst fragmenten bestaat (die process.stdout.write niet accepteert): zonder deze controle weigert de strikte modus te compileren.

De stream beschikbaar stellen via Express

Een stream die de terminal nooit verlaat, helpt niemand. Hier leest u hoe u deze doorgeeft aan een browser met Server-Sent Events vanuit een Express-API. De vraag wordt gevalideerd voordat er een aanroep plaatsvindt om te voorkomen dat een leeg verzoek naar de API wordt gestuurd. De drie headers openen vervolgens het kanaal, elk fragment wordt teruggestuurd als JSON in een data:-event, en een [DONE]-marker signaleert de client om de verbinding te sluiten.

import express from 'express';
import { Mistral } from '@mistralai/mistralai';

const app = express();
const client = new Mistral({ apiKey: process.env.MISTRAL_API_KEY });

app.get('/api/chat', async (req, res) => {
  const question = typeof req.query.q === 'string' ? req.query.q : '';
  if (!question) {
    res.status(400).json({ error: 'Missing q parameter' });
    return;
  }

  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');

  const stream = await client.chat.stream({
    model: 'mistral-small-latest',
    messages: [{ role: 'user', content: question }],
  });

  for await (const chunk of stream) {
    const content = chunk.data.choices[0]?.delta.content;
    if (typeof content === 'string' && content) {
      res.write(`data: ${JSON.stringify({ text: content })}\n\n`);
    }
  }

  res.write('data: [DONE]\n\n');
  res.end();
});

app.listen(3000, () => console.log('Server on port 3000'));

Gesprekken met meerdere beurten

Het beheer van de geschiedenis volgt hetzelfde principe als in Python: het model heeft geen geheugen, dus u onderhoudt een array van berichten en stuurt bij elke beurt het geheel opnieuw. In TypeScript voorkomt het declareren van een expliciet Message-type dat u een niet-bestaande rol of een misvormd object introduceert – een fout die de API anders als een 400 zou retourneren.

import { Mistral } from '@mistralai/mistralai';

type Message = {
  role: 'system' | 'user' | 'assistant';
  content: string;
};

const client = new Mistral({ apiKey: process.env.MISTRAL_API_KEY });

const historique: Message[] = [
  {
    role: 'system',
    content: 'You are an expert TypeScript assistant. Respond in English.',
  },
];

async function poserQuestion(question: string): Promise<string> {
  historique.push({ role: 'user', content: question });

  const response = await client.chat.complete({
    model: 'mistral-small-latest',
    messages: historique,
  });

  const contenu = response.choices[0]?.message?.content;
  const reponse = typeof contenu === 'string' ? contenu : '';
  historique.push({ role: 'assistant', content: reponse });

  return reponse;
}

async function main() {
  console.log(await poserQuestion('What is a generic type?'));
  console.log(await poserQuestion('Show me a concrete example.'));
  console.log(await poserQuestion('How do I add constraints?'));
}

main();

De typeof contenu === 'string'-controle is geen luxe: het veld content van de respons kan een lijst fragmenten zijn, terwijl uw Message-type een string verwacht. Observeer vervolgens de derde vraag: “How do I add constraints?” is alleen zinvol omdat de twee vorige uitwisselingen nog steeds in de array staan. Daag uzelf uit door de regel die het antwoord van de assistent aan de geschiedenis toevoegt te verwijderen; u zult zien dat het model bij de tweede beurt de draad kwijtraakt.

Generatie afstemmen en fouten afhandelen

Geavanceerde parameters zijn identiek aan die van de Python SDK – alleen de hoofdlettergebruik verandert. Een lage temperature voor een gestructureerd deliverable en een maxTokens die is afgestemd op de verwachte lengte, leveren voorspelbaardere responsen op. Stel temperature of topP in, niet beide: dit is de aanbeveling in de API-documentatie, die een temperature tussen 0 en 0,7 adviseert.

const response = await client.chat.complete({
  model: 'mistral-large-latest',
  messages: [
    { role: 'user', content: 'Propose an architecture for a B2B SaaS.' },
  ],
  temperature: 0.5,
  maxTokens: 1000,
});

Tot slot kan elke netwerkaanroep mislukken: ongeldige sleutel, overschreden quota, uitval. Omhul de aanroep altijd met een try/catch en controleer het fouttype voordat u de eigenschappen uitleest, anders weigert TypeScript te compileren. Alle HTTP-fouten die door de API worden teruggegeven, erven van MistralError, dat statusCode en body blootlegt; netwerkfouten (ConnectionError, RequestTimeoutError, enz.) erven hier niet van, maar blijven wel Error-instanties.

import * as errors from '@mistralai/mistralai/models/errors';

try {
  const response = await client.chat.complete({
    model: 'mistral-small-latest',
    messages: [{ role: 'user', content: 'Hello!' }],
  });
  console.log(response.choices[0]?.message?.content);
} catch (error) {
  if (error instanceof errors.MistralError) {
    // API error response: 401 key refused, 429 limit reached...
    console.error(`Mistral API Error ${error.statusCode}: ${error.message}`);
  } else if (error instanceof Error) {
    // No API response: network down, timeout exceeded...
    console.error(`Error: ${error.message}`);
  }
}

Belangrijkste punten

  • client.chat.complete() is asynchroon – gebruik await
  • Streaming gebruikt for await...of op het resultaat van client.chat.stream()
  • TypeScript-typering vangt parameterfouten op tijdens het compileren
  • SSE-integratie met Express is eenvoudig voor real-time webinterfaces
  • Gespreksgeschiedenis wordt beheerd met een getypeerde Message[]-array
  • content is een string of een lijst fragmenten: test typeof content === 'string' voordat u het als tekst gebruikt
  • HTTP-fouten van de SDK erven van MistralError (statusCode, body)