Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

První volání a streamování v TypeScriptu

Lekce 9 z 14 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Odeslání prvního požadavku
  2. Streamování
  3. Konverzace s více obraty
  4. Ladění generování a zpracování chyb
  5. Klíčové poznatky

Lekce aktualizována 3. listopadu 2026 po kompilaci příkladů v přísném režimu se SDK @mistralai/mistralai 3.5.0 a TypeScriptem 7.0.2. Typy SDK definují content jako string | ContentChunk[]: konverzace s více obraty a smyčky pro streamování se bez kontroly typeof content === 'string' nepodařilo zkompilovat. Příklad konfigurace dříve kombinoval temperature a topP, což dokumentace API nedoporučuje měnit současně. Zpracování chyb nyní využívá třídu MistralError z SDK a trasa v Express validuje otázku před voláním API. Zdroje: Mistral TypeScript SDK (README) · parametry dokončení chatu.

Odeslání prvního požadavku

Nyní, když máš SDK nainstalované, pojďme přejít k praxi. Metoda chat.complete() v TypeScript SDK je přesným ekvivalentem té v Python SDK: stejné parametry, stejná struktura odpovědi, až na konvence pojmenování. Pokud jsi sledoval lekce o Pythonu, pohybuješ se na známém území; nová je pouze asynchronní syntaxe JavaScriptu.

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

Otazníky v response.choices[0]?.message?.content nejsou jen pro okrasu: v typech SDK jsou message a content volitelné a choices[0] neexistuje, pokud se seznam vrátí prázdný. Bezpečný přístup vrátí undefined místo vyhození výjimky. Všimni si také, že content není vždy řetězec: SDK ho typuje jako string | ContentChunk[], protože odpověď může přijít jako seznam fragmentů (text, uvažování thinking, reference atd.).

Pochopení odpovědi

Struktura odpovědi je totožná s Python SDK. Její parsování ti pomůže pochopit, za co platíš a proč se odpověď zastavila. Následující příklad extrahuje text, důvod zastavení a počet tokenů jeden po druhém; jejich vypisování donutí editor navrhnout každé pole, což dokazuje, že typování funguje.

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

  // Text odpovědi
  const texte = response.choices[0]?.message?.content;

  // Důvod zastavení
  const finRaison = response.choices[0]?.finishReason;

  // Statistika tokenů
  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}`);
}

Všimni si rozdílného zápisu: zatímco Python expose max_tokens, finish_reason a prompt_tokens, TypeScript používá maxTokens, finishReason a promptTokens. To je chyba číslo jedna při ručním převodu příkladu z Pythonu – a kompilátor ji okamžitě označí.

Streamování

Streamování je pro webová rozhraní nezbytné: bez něj uživatel hledí na zmrazenou obrazovku několik sekund; s ním se text objevuje slovo po slově a vnímaná latence dramaticky klesá. TypeScript SDK vystavuje stream jako asynchronní generátor, kterým iteruješ pomocí 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();
}

Dva detaily si zaslouží tvou pozornost. Obsah se nachází v chunk.data, nikoli přímo v chunk: toto je obálka události SDK od verze 1.0. A kontrola typeof content === 'string' filtruje jak fragmenty bez obsahu, které by znečišťovaly výstup hodnotou undefined, tak obsah ve formě seznamu fragmentů, který process.stdout.write nepřijímá: bez ní by přísný režim odmítl kompilaci.

Exponování streamu přes Express

Stream, který nikdy neopustí terminál, nikomu nepomůže. Zde je návod, jak jej předat do prohlížeče pomocí Server-Sent Events z API postaveného na Expressu. Otázka je validována před jakýmkoli voláním, aby se předešlo odeslání prázdného požadavku na API. Tři hlavičky následně otevřou kanál, každý fragment je odeslán zpět jako JSON v události data: a značka [DONE] signalizuje klientovi uzavření spojení.

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

Konverzace s více obraty

Správa historie funguje na stejném principu jako v Pythonu: model nemá paměť, takže udržuješ pole zpráv a při každém obratu odesíláš celé znovu. V TypeScriptu deklarace explicitního typu Message zabraňuje vkládání neexistující role nebo chybně vytvořeného objektu – chyby, kterou by API jinak vrátilo jako 400.

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

Kontrola typeof contenu === 'string' není luxus: pole content v odpovědi může být seznamem fragmentů, zatímco tvůj typ Message očekává řetězec. Všimni si také třetí otázky: „How do I add constraints?“ dává smysl pouze proto, že jsou v poli stále přítomny dvě předchozí výměny. Vyzkoušej si to odstraněním řádku, který přidává odpověď asistenta do historie, a uvidíš, jak model ve druhém kole ztratí vlákno.

Ladění generování a zpracování chyb

Pokročilé parametry jsou totožné s těmi v Python SDK – mění se pouze zápis. Nízká hodnota temperature pro strukturovaný výstup a maxTokens kalibrované na očekávanou délku přinášejí předvídatelnější odpovědi. Nastav buď temperature, nebo topP, ne obojí: toto je doporučení dokumentace API, která radí hodnotu temperature mezi 0 a 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,
});

Nakonec, jakékoli síťové volání může selhat: neplatný klíč, překročený limit, výpadek. Vždy obal volání do bloku try/catch a před čtením jeho vlastností zkontroluj typ chyby, jinak TypeScript odmítne kompilaci. Všechny HTTP chyby vrácené API dědí od MistralError, která expose statusCode a body; síťové chyby (ConnectionError, RequestTimeoutError atd.) od ní nedědí, ale zůstávají instancemi Error.

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) {
    // Chybová odpověď API: 401 klíč odmítnut, 429 dosažen limit...
    console.error(`Mistral API Error ${error.statusCode}: ${error.message}`);
  } else if (error instanceof Error) {
    // Žádná odpověď API: síť nefunguje, překročen časový limit...
    console.error(`Error: ${error.message}`);
  }
}

Klíčové poznatky

  • client.chat.complete() je asynchronní – použij await
  • Streamování využívá for await...of na výsledku client.chat.stream()
  • Typování v TypeScriptu zachytí chyby v parametrech již při kompilaci
  • Integrace SSE s Expressem je pro rozhraní v reálném čase přímočará
  • Historie konverzace se spravuje pomocí typovaného pole Message[]
  • content je buď řetězec, nebo seznam fragmentů: před použitím jako text otestuj typeof content === 'string'
  • HTTP chyby SDK dědí od MistralError (statusCode, body)