Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Modellen mistral-embed

Lektion 2 af 18 Opdateret 2. november 2026 Udvikler
På denne side
  1. Oversigt over mistral-embed
  2. Opsætning og installation
  3. Generering af indlejringer
  4. Struktur af API-svar
  5. Komplet eksempel: Kodning og lagring
  6. Begrænsninger og bedste praksis
  7. Vigtige pointer

Oversigt over mistral-embed

mistral-embed er Mistral AIs tekstindlejringsmodel. Den transformerer enhver tekst til en 1024-dimensionel vektor, uanset inputlængden – hvad enten det er en kort sætning eller et helt afsnit, har outputvektoren altid samme størrelse. Denne faste dimensionalitet er ikke en ubetydelig detalje: Den giver dig mulighed for at indeksere både en produkttitel og dens fulde beskrivelse i det samme vektorrum og derefter sammenligne dem direkte uden nogen særlig behandling for at afstemme forskellige formater.

Denne model er optimeret til opgaver inden for semantisk søgning, klassificering og klyngedannelse på naturligt sprog (artikler, dokumenter, samtaler og mere). Brug den til at indeksere en vidensbase, FAQ, referater fra møder eller et årtis supportbilletter.

Opsætning og installation

Før du kalder API’et, skal du installere Mistral Python SDK og konfigurere din API-nøgle:

# Installation
# pip install mistralai

import os
from mistralai.client import Mistral

# Initialiser klienten
api_key = os.environ.get("MISTRAL_API_KEY")
client = Mistral(api_key=api_key)

Hent din API-nøgle i Mistral-konsollen. Gem den i en miljøvariabel for at holde den ude af din kode. At læse via os.environ.get er ikke bare teoretisk hygiejne: Det forhindrer, at din nøgle ender i et øjebliksbillede af Git-historikken den dag, dit projekt bliver offentligt.

Generering af indlejringer

API-kaldet er ligetil: Send en liste med tekster og modtag de tilsvarende vektorer. Bemærk, at selv for en enkelt tekst skal inputtet være en liste – API’et arbejder altid i batches, hvilket betaler sig, så snart dit korpus vokser.

from mistralai.client import Mistral

client = Mistral(api_key=api_key)

# Generer indlejringer for én eller flere tekster
response = client.embeddings.create(
    model="mistral-embed",
    inputs=[
        "Indlejringer fanger semantisk betydning.",
        "Mistral AI tilbyder højtydende modeller.",
        "RAG forbedrer svar kvaliteten."
    ],
)

# Få adgang til vektorerne
for i, data in enumerate(response.data):
    print(f"Tekst {i+1}: vektor på {len(data.embedding)} dimensioner")
    print(f"  Første elementer: {data.embedding[:5]}")

Typisk output:

Tekst 1: vektor på 1024 dimensioner
  Første elementer: [0.0234, -0.1567, 0.0891, 0.0123, -0.0456]
Tekst 2: vektor på 1024 dimensioner
  Første elementer: [0.0189, -0.1234, 0.0678, 0.0345, -0.0567]
Tekst 3: vektor på 1024 dimensioner
  Første elementer: [0.0312, -0.1456, 0.0789, 0.0234, -0.0345]

Struktur af API-svar

Svaret indeholder mere end blot vektorer. Det fortæller dig også, hvilken model der faktisk blev brugt, og hvor mange tokens der blev forbrugt – to oplysninger, du vil ønske at logge, når kodning kører i produktion, og nogen skal forklare regningen. Vær særligt opmærksom på feltet index: Det angiver positionen for teksten i den liste, du sendte, så du kan mappe hver vektor tilbage til sit kildedokument.

response = client.embeddings.create(
    model="mistral-embed",
    inputs=["Eksempeltekst der skal kodes."],
)

# Svarobjekt
print(response.model)          # "mistral-embed"
print(response.usage)          # forbrugte tokens

# Indlejringsdata
embedding_data = response.data[0]
print(embedding_data.index)     # 0 (position i inputs-listen)
print(len(embedding_data.embedding))  # 1024
print(type(embedding_data.embedding))  # list[float]

Komplet eksempel: Kodning og lagring

Her er en typisk pipeline til kodning af et dokumentkorpus og klargøring af vektorer til senere søgning. Skiftet til NumPy er det kritiske skridt: Mens dine vektorer er Python-lister, sker hver similarietsberegning element for element; når du først har bygget en matrix, sammenligner en enkelt operation forespørgslen mod hele korpussen.

import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

# Dokumentkorpus
documents = [
    "Mistral AI er en fransk virksomhed inden for kunstig intelligens.",
    "RAG kombinerer informationssøgning og tekstgenerering.",
    "Indlejringer muliggør semantisk søgning.",
    "Python er det mest udbredte sprog inden for data science.",
    "FAISS er et bibliotek til vektorsøgning fra Meta.",
]

# Kod alle dokumenter
response = client.embeddings.create(
    model="mistral-embed",
    inputs=documents,
)

# Konverter til en NumPy-matrix til beregninger
embeddings_matrix = np.array([d.embedding for d in response.data])

print(f"Indlejringsmatrix: {embeddings_matrix.shape}")
# Indlejringsmatrix: (5, 1024)

# Gem til senere brug
np.save("document_embeddings.npy", embeddings_matrix)

At gemme som .npy undgår, at du betaler for at genkode hver gang din applikation genstarter. På et korpus på flere tusinde dokumenter er dette forskellen mellem øjeblikkelig opstart og flere minutters fakturerede API-kald.

Begrænsninger og bedste praksis

Fire faktorer bestemmer kvaliteten af dine resultater. For det første maksimal længde: Modellen afkorter tekster, der er for lange, og afkortningen er tavs – en rapport på fyrre sider kodet i én blok vil effektivt kun repræsentere begyndelsen. Foretræk bidder på 512 til 2048 tokens, som dækkes i lektionen om chunking.

For det andet skelner mistral-embed, i modsætning til nogle andre API’er, ikke mellem query og document: Der er ingen inputtype, du sender blot teksten. I praksis går brugerspørgsmål og indekserede dokumenter gennem det samme kald med de samme parametre, hvilket forenkler din søgekode.

Det tredje punkt er omkostninger: Indlejringer faktureres per token. Det koster det samme i tokens at kode tusind dokumenter ét ad gangen som at kode dem i en batch, men det ganger netværksrundture og behandlingstid op; du optimerer ved at batche kald, hvilket er emnet for næste lektion om batching. Endelig arbejder determinisme til din fordel: For den samme tekst returnerer modellen altid den samme vektor. Du kan derfor cache indlejringer efter tekst-hash og kun genkode det, der faktisk er ændret mellem to versioner af et dokument.

Vigtige pointer

  • mistral-embed producerer 1024-dimensionelle vektorer for enhver tekst
  • API’et accepterer en liste med inputs og returnerer de tilsvarende vektorer
  • Vektorer er lister med flydende tal, der nemt kan konverteres til NumPy-arrays
  • Gem dine indlejringer som en NumPy-matrix til similarietsberegninger
  • Husk at opdele lange tekster før kodning