Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Installera Mistral TypeScript SDK

Lektion 8 av 14 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Varför använda TypeScript SDK?
  2. Förutsättningar
  3. Installation
  4. TypeScript-konfiguration
  5. Konfigurera miljövariabeln
  6. Verifiera installationen
  7. Organisera projektet
  8. Viktiga punkter

Lektionen uppdaterad 3 november 2026 efter körning av exemplen med @mistralai/mistralai SDK 3.5.0 och TypeScript 7.0.2. Den ursprungliga versionen gick inte att kompilera. Att köra npx tsc utan att TypeScript är installerat laddar ner det övergivna npm-paketet tsc (version 2.0.4) istället för kompilatorn. Testskriptet låg utanför mappen src som deklarerats i tsconfig.json. Objektet process känns endast igen med @types/node. Slutligen nekar strikt läge models.data.length och model.id utan föregående validering. tsconfig.json följer nu TypeScript-guidens scenario “kompilera och kör sedan med Node.js”, och Node.js 18 samt 20, som nått slutet av sin livscykel, listas inte längre som tillräckliga. Källor: Ladda ner TypeScript · Välja kompilatoralternativ (TypeScript) · Ändringar i TypeScript 6.0 · tsx och TypeScript · SDK-stödda körtider · Node.js release-schemaläggning.

Varför använda TypeScript SDK?

Om din stack bygger på Node.js, Deno eller Bun låter Mistral TypeScript SDK dig integrera modeller direkt i dina JavaScript- och TypeScript-applikationer. Du undviker mellanliggande Python-lager eller att skriva anpassade HTTP-anrop. Detta är det vanligaste scenariot när du lägger till AI i en befintlig webbapplikation: ett Express-API, en Next.js-backend eller en Node-arbetare som bearbetar en mediekö.

TypeScripts statiska typning ger ett säkerhetsnät som betalar sig inom den första utvecklingstimmen. Din editor kompletterar parameternamn istället för att du ska gissa mellan maxTokens och max_tokens; skiftfelsfel eller påhittade fält utlöses vid kompilering, inte i produktion klockan 03.00; och parameterdokumentation visas vid hovring utan att du behöver lämna filen. Detta säkerhetsnät är ännu viktigare eftersom API-svar är nästlade objekt där det är lätt att missa en nivå.

Förutsättningar

SDK:t riktar sig till underhållna LTS-versioner av Node.js. Från och med den 3 november 2026 är detta version 22, 24 och 26; Node.js 18 och 20 får inte längre säkerhetsuppdateringar. Kontrollera din version med node --version innan du fortsätter: SDK:t förlitar sig på ES-moduler och det inbyggda fetch-API:t. Du behöver också en pakethanterare (npm, yarn eller pnpm) samt en Mistral API-nyckel som skapats och är tillgänglig som en miljövariabel, enligt vad som behandlats i tidigare lektioner.

Installation

Det officiella SDK:t publiceras på npm som @mistralai/mistralai:

# Med npm
npm install @mistralai/mistralai

# Med yarn
yarn add @mistralai/mistralai

# Med pnpm
pnpm add @mistralai/mistralai

TypeScript-konfiguration

Om du använder TypeScript – vilket vi rekommenderar – installera tre verktyg som utvecklingsberoenden: kompilatorn, tsx (som kör .ts-filer utan ett byggsteg) och @types/node (som beskriver Node.js-objekt som process för TypeScript):

npm install -D typescript tsx @types/node

Hoppa inte över detta steg. Utan TypeScript installerat i projektet hämtar npx tsc paketet tsc från npm – en övergiven legacy-kompilator (2.0.4) – istället för TypeScript. Deklarera därefter projektet som ES-moduler, vilket TypeScript-dokumentationen kräver för kod som kompileras och sedan körs av Node.js:

npm pkg set type=module

Skapa slutligen tsconfig.json. Det använder de inställningar som den officiella TypeScript-guiden rekommenderar för detta scenario (module: nodenext). Det aktiverar också strikt läge, vilket tvingar dig att hantera potentiellt saknade värden i API-svar – en hälsosam begränsning – och kompilerar src/ till dist/:

{
  "compilerOptions": {
    "target": "esnext",
    "module": "nodenext",
    "types": ["node"],
    "strict": true,
    "skipLibCheck": true,
    "rootDir": "src",
    "outDir": "dist"
  },
  "include": ["src"]
}

Tre rader förtjänar en förklaring, då var och en förhindrar ett fel vi stötte på vid testning av denna lektion:

  • "types": ["node"] laddar Node.js-typer. Sedan TypeScript 6.0 laddas @types-paket inte längre automatiskt. Utan denna rad utlöser process.env felet “Cannot find name ‘process’”, även om @types/node är installerat.
  • "rootDir": "src" anger källroten för kompilerade filer: src/test-mistral.ts blir dist/test-mistral.js. Utan detta rapporterar TypeScript 7 fel TS5011 när dina källfiler inte finns i projektroten.
  • "skipLibCheck": true hoppar över typkontroll av beroendens deklarationsfiler. Detta är också en standardinställning i tsconfig.json som genereras av npx tsc --init. Med SDK 3.5.0 och TypeScript 7 orsakar utelämnande av detta ett fel i SDK:ts egna deklarationer som din kod inte kan åtgärda.

SDK:t publiceras som ES-moduler och buntar sina egna typer: inget @types/-paket behövs för det. Om din editor saknar autokomplettering ligger problemet i din tsconfig.json, inte i ett saknat typer-paket.

Konfigurera miljövariabeln

Hardkoda aldrig API-nyckeln i din källkod. I Node.js är standardlösningen dotenv, som laddar variabler från en lokal fil vid processstart:

npm install dotenv

Skapa en .env-fil i projektroten:

MISTRAL_API_KEY=din-api-nyckel-här

Lägg till denna fil i din .gitignore omedelbart, före ditt första commit. Det är vid exakt detta tillfälle nycklar läcker:

.env
.env.local

Importen dotenv/config måste föregå all läsning av process.env. Annars förblir variabeln odefinierad när du instansierar klienten:

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

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

Verifiera installationen

Innan du skriver affärslogik, validera hela kedjan – installation, nyckel, nätverk – med ett minimalt skript. Skapa src/test-mistral.ts och begär helt enkelt listan över modeller som är tillgängliga för ditt konto:

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

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

  // Lista tillgängliga modeller
  const models = await client.models.list();
  const liste = models.data ?? [];
  console.log(`Available models: ${liste.length}`);

  for (const model of liste.slice(0, 5)) {
    // En modelltyp okänd för denna SDK-version markeras som 'UNKNOWN'
    if (model.type === 'UNKNOWN') continue;
    console.log(`  - ${model.id}`);
  }
}

main().catch(console.error);

Dessa två kontroller är inte dekorativa. SDK:t deklarerar data som valfritt, och varje listpost är antingen ett basmodellkort, ett finjusterat modellkort eller ett okänt värde (type: 'UNKNOWN'). När API:t lägger till en ny modelltyp bevarar SDK:t den i denna form istället för att krascha. Utan dessa två tester vägrar strikt läge att kompilera.

I utvecklingsmiljön kör du det med tsx, som installerades tidigare, vilket transpilerar i flytande och sparar dig ett byggsteg:

npx tsx src/test-mistral.ts

Varning: tsx kontrollerar inte typer; det tar bort dem och exekuterar. Endast tsc rapporterar typfel. Kör npx tsc --noEmit för att kontrollera utan att kompilera. För att kompilera och sedan köra, precis som din byggpipeline kommer att göra:

npx tsc && node dist/test-mistral.js

En giltig nyckel visar modellantalet och de första fem posterna. En avvisad nyckel visar ett fel med Status 401 (Invalid API Key): kedjan fungerar, endast nyckeln är felaktig.

Organisera projektet

När verifieringen är klar strukturerar du projektet så att nyckeln och klienten inte sprids över filer:

mon-projet/
├── src/
│   ├── index.ts          # Startpunkt
│   ├── mistral-client.ts # Klientinitiering (singleton)
│   └── utils/
├── .env                  # Miljövariabler (git-ignorerad)
├── .gitignore
├── package.json
└── tsconfig.json

Att centralisera klientinitieringen i en dedikerad modul undviker att återskapa den i varje fil. Ännu viktigare är att det får applikationen att misslyckas vid start snarare än vid det första användaranropet om nyckeln saknas:

// src/mistral-client.ts
import { Mistral } from '@mistralai/mistralai';

if (!process.env.MISTRAL_API_KEY) {
  throw new Error('Variabeln MISTRAL_API_KEY krävs.');
}

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

Resten av koden importerar helt enkelt denna färdigbyggda klient:

// src/index.ts
import 'dotenv/config';
import { mistral } from './mistral-client.js';

Observera tillägget .js i den relativa importen. Med module: nodenext kräver TypeScript filnamnet såsom det kommer att existera efter kompilering, och tsx vet hur det ska mappas till .ts-filen. Importordningen spelar också roll: dotenv/config exekveras före mistral-client.js, så nyckeln laddas när den modulen kontrollerar dess förekomst.

Viktiga punkter

  • Installera TypeScript SDK med npm install @mistralai/mistralai
  • Huvudimporten är import { Mistral } from '@mistralai/mistralai'
  • Installera typescript, tsx och @types/node som utvecklingsberoenden innan du anropar npx tsc
  • Använd module: nodenext och "type": "module" för kod som kompileras och sedan körs av Node.js; relativa importer tar tillägget .js
  • Använd en .env-fil med dotenv för att hantera API-nyckeln
  • SDK:t tillhandahåller inbyggda TypeScript-typer: utnyttja autokomplettering och låt tsc kontrollera det som tsx hoppar över
  • Centralisera klientinitieringen i en dedikerad modul