Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Første kald og streaming i TypeScript

Lektion 9 af 14 Opdateret 3. november 2026 Udvikler
På denne side
  1. Send din første anmodning
  2. Streaming
  3. Samtaler over flere runder
  4. Justering af generering og håndtering af fejl
  5. Vigtige pointer

Lektion opdateret 3. november 2026 efter kompilering af eksempler i streng tilstand med SDK @mistralai/mistralai 3.5.0 og TypeScript 7.0.2. SDK-typen for content er string | ContentChunk[]: samtaler over flere runder og streaming-løkker kunne ikke kompilere uden en kontrol af typeof content === 'string'. Konfigurationseksemplet kombinerede tidligere temperature og topP, hvilket API-dokumentationen fraråder at ændre samtidigt. Håndtering af fejl bruger nu SDK-klassen MistralError, og Express-ruten validerer spørgsmålet, før API’et kaldes. Kilder: Mistral TypeScript SDK (README) · parametre for chat-fuldførelse.

Send din første anmodning

Nu hvor SDK’et er installeret, bliver det praktisk. TypeScript SDK’ets metode chat.complete() svarer nøjagtigt til Python SDK’ets: samme parametre, samme svarstruktur, bortset fra navngivningskonventioner. Hvis du har fulgt Python-lektionerne, er du på bekendt grund; kun JavaScripts asynkrone syntaks er ny for dig.

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

Spørgsmålstegnene i response.choices[0]?.message?.content er ikke blot pynt: i SDK-typerne er message og content valgfrie, og choices[0] eksisterer ikke, hvis listen returneres tom. Sikker adgang returnerer undefined i stedet for at udløse en undtagelse. Bemærk også, at content ikke altid er en streng: SDK’et definerer typen som string | ContentChunk[], fordi et svar kan ankomme som en liste over fragmenter (tekst, thinking-ræsonnement, referencer osv.).

Forstå svaret

Svarstrukturen er identisk med Python SDK’ets. At analysere det hjælper dig med at forstå, hvad du betaler for, og hvorfor et svar stoppede. Følgende eksempel udtrækker teksten, stopårsagen og antallet af tokens ét ad gangen; når du skriver det ud, vil din editor foreslå hvert felt, hvilket beviser, at typiseringen gør sit arbejde.

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

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

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

  // Token-statistik
  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}`);
}

Bemærk store/små bogstaver: Hvor Python eksponerer max_tokens, finish_reason og prompt_tokens, bruger TypeScript maxTokens, finishReason og promptTokens. Dette er den hyppigste fejl, når man manuelt overfører et Python-eksempel – og kompileren vil straks flagge det.

Streaming

Streaming er afgørende for webgrænseflader: uden det stirrer brugeren på en frossen skærm i flere sekunder; med det vises teksten ord for ord, og den oplevede ventetid kollapser. TypeScript SDK’et eksponerer streamen som en asynkron generator, som du itererer over med 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();
}

To detaljer fortjener din opmærksomhed. Indholdet findes i chunk.data, ikke direkte i chunk: dette er SDK’ets begivenheds-wrapper siden version 1.0. Og kontrollen typeof content === 'string' filtrerer både fragmenter uden indhold, som ville fyldes din output med undefined, og indhold bestående af lister over fragmenter, som process.stdout.write ikke accepterer: uden den nægter streng tilstand at kompilere.

Eksponér streamen via Express

En stream, der aldrig forlader terminalen, hjælper ingen. Her er hvordan du videresender den til en browser ved hjælp af Server-Sent Events fra et Express-API. Spørgsmålet valideres, før ethvert kald for at undgå at sende en tom anmodning til API’et. De tre headere åbner derefter kanalen, hvert fragment sendes tilbage som JSON i en data:-begivenhed, og en [DONE]-markør signalerer klienten at lukke forbindelsen.

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

Samtaler over flere runder

Håndtering af historik følger samme princip som i Python: modellen har ingen hukommelse, så du vedligeholder en array af beskeder og gensender hele sættet ved hver runde. I TypeScript forhindrer deklaration af en eksplicit Message-type, at du utilsigtet indsætter en ikke-eksisterende rolle eller et misdannet objekt – en fejl, som API’et ellers ville returnere som en 400-fejl.

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

Kontrollen typeof contenu === 'string' er ikke en luksus: feltet content i svaret kan være en liste over fragmenter, mens din Message-type forventer en streng. Læg derefter mærke til det tredje spørgsmål: „How do I add constraints?” giver kun mening, fordi de to tidligere udvekslinger stadig findes i arrayet. Udvid øvelsen ved at fjerne linjen, der tilføjer assistentens svar til historikken, og du vil se modellen miste tråden ved anden runde.

Justering af generering og håndtering af fejl

Avancerede parametre er identiske med Python SDK’ets – kun store/små bogstaver ændres. En lav temperature til en struktureret leverance og en maxTokens kalibreret til den forventede længde giver mere forudsigelige svar. Indstil temperature eller topP, ikke begge: dette er API-dokumentationens anbefaling, som råder til en temperature mellem 0 og 0,7.

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

Endelig kan ethvert netværkskald fejle: ugyldig nøgle, overskredet kvote, nedetid. Omslut altid kaldet i en try/catch og tjek fejltypen, før du læser dens egenskaber; ellers vil TypeScript nægte at kompilere. Alle HTTP-fejl returneret af API’et arver fra MistralError, som eksponerer statusCode og body; netværksfejl (ConnectionError, RequestTimeoutError osv.) arver ikke fra den, men forbliver Error-instanser.

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-fejlrespons: 401 nøgle afvist, 429 grænse nået...
    console.error(`Mistral API Error ${error.statusCode}: ${error.message}`);
  } else if (error instanceof Error) {
    // Intet API-respons: netværk nede, timeout overskredet...
    console.error(`Error: ${error.message}`);
  }
}

Vigtige pointer

  • client.chat.complete() er asynkron – brug await
  • Streaming bruger for await...of på resultatet af client.chat.stream()
  • TypeScript-typisering fanger parameterfejl på kompileringstidspunktet
  • SSE-integration med Express er ligetil for webgrænseflader i realtid
  • Samtalehistorik administreres med en typiseret array Message[]
  • content er enten en streng eller en liste over fragmenter: test typeof content === 'string', før du bruger det som tekst
  • SDK HTTP-fejl arver fra MistralError (statusCode, body)