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

Modellen mistral-embed

Lektion 2 av 18 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Översikt över mistral-embed
  2. Installation och konfiguration
  3. Generering av inbäddningar
  4. Struktur på API-svaret
  5. Komplett exempel: Koda och lagra
  6. Begränsningar och bästa praxis
  7. Viktiga punkter

Översikt över mistral-embed

mistral-embed är Mistral AIs modell för textinbäddningar. Den omvandlar valfri text till en 1024-dimensionell vektor, oavsett inmatningens längd – vare sig det är en kort mening eller ett helt stycke har utmatningsvektorn alltid samma storlek. Denna fasta dimensionalitet är ingen bagatell: den låter dig indexera både en produkttitel och dess fullständiga beskrivning i samma vektorrum och sedan jämföra dem direkt utan någon särskild bearbetning för att synka olika format.

Modellen är optimerad för semantisk sökning, klassificering och klustring av text på naturligt språk (artiklar, dokument, konversationer med mera). Använd den för att indexera en kunskapsbas, FAQ, mötesprotokoll eller ett decennium av supportärenden.

Installation och konfiguration

Innan du anropar API:t installerar du Mistral Python SDK och konfigurerar din API-nyckel:

# Installation
# pip install mistralai

import os
from mistralai.client import Mistral

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

Hämta din API-nyckel från Mistral-konsolen. Lagra den i en miljövariabel för att hålla den borta från din kod. Att läsa via os.environ.get är inte bara teoretisk hygien: det förhindrar att din nyckel hamnar i en ögonblicksbild av Git-historiken den dag ditt projekt blir offentligt.

Generering av inbäddningar

API-anropet är rakt på sak: skicka en lista med texter och hämta motsvarande vektorer. Observera att även för en enda text måste inmatningen vara en lista – API:t arbetar alltid i batchar, vilket lönar sig så snart din korpus växer.

from mistralai.client import Mistral

client = Mistral(api_key=api_key)

# Generera inbäddningar för en eller flera texter
response = client.embeddings.create(
    model="mistral-embed",
    inputs=[
        "Embeddings fångar semantisk betydelse.",
        "Mistral AI erbjuder högpresterande modeller.",
        "RAG förbättrar svars kvaliteten."
    ],
)

# Kom åt vektorerna
for i, data in enumerate(response.data):
    print(f"Text {i+1}: vektor med {len(data.embedding)} dimensioner")
    print(f"  Första elementen: {data.embedding[:5]}")

Typisk utmatning:

Text 1: vektor med 1024 dimensioner
  Första elementen: [0.0234, -0.1567, 0.0891, 0.0123, -0.0456]
Text 2: vektor med 1024 dimensioner
  Första elementen: [0.0189, -0.1234, 0.0678, 0.0345, -0.0567]
Text 3: vektor med 1024 dimensioner
  Första elementen: [0.0312, -0.1456, 0.0789, 0.0234, -0.0345]

Struktur på API-svaret

Svaret innehåller mer än bara vektorer. Det berättar också vilken modell som faktiskt användes och hur många tokens som konsumerades – två uppgifter du vill logga när kodningen körs i produktion och någon behöver förklara fakturan. Var särskilt uppmärksam på fältet index: det anger textens position i listan du skickade, vilket låter dig mappa varje vektor tillbaka till sitt källdokument.

response = client.embeddings.create(
    model="mistral-embed",
    inputs=["Exempeltext att koda."],
)

# Svarsobjekt
print(response.model)          # "mistral-embed"
print(response.usage)          # konsumerade tokens

# Inbäddningsdata
embedding_data = response.data[0]
print(embedding_data.index)     # 0 (position i inputs-listan)
print(len(embedding_data.embedding))  # 1024
print(type(embedding_data.embedding))  # list[float]

Komplett exempel: Koda och lagra

Här är en typisk pipeline för att koda en dokumentkorpus och förbereda vektorer för framtida sökning. Bytet till NumPy är det kritiska steget: medan dina vektorer är Python-listor sker varje likhetsberäkning element för element; så snart du bygger en matris jämför en enda operation frågan mot hela korpusen.

import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

# Dokumentkorpus
documents = [
    "Mistral AI är ett franskt företag inom artificiell intelligens.",
    "RAG kombinerar informationssökning och textgenerering.",
    "Inbäddningar möjliggör semantisk sökning.",
    "Python är det mest använda språket inom data science.",
    "FAISS är ett bibliotek för vektorsökning från Meta.",
]

# Koda alla dokument
response = client.embeddings.create(
    model="mistral-embed",
    inputs=documents,
)

# Konvertera till en NumPy-matris för beräkningar
embeddings_matrix = np.array([d.embedding for d in response.data])

print(f"Inbäddningsmatris: {embeddings_matrix.shape}")
# Inbäddningsmatris: (5, 1024)

# Spara för senare användning
np.save("document_embeddings.npy", embeddings_matrix)

Att spara som .npy undviker att du betalar för att koda om varje gång din applikation startas om. På en korpus med flera tusen dokument är detta skillnaden mellan omedelbar start och flera minuter av fakturerade API-anrop.

Begränsningar och bästa praxis

Fyra faktorer avgör kvaliteten på dina resultat. För det första, maximal längd: modellen trunkerar texter som är för långa, och trunkeringen är tyst – en rapport på fyrtio sidor som kodas i ett block kommer effektivt att representera endast början. Föredra bitar på 512 till 2048 tokens, vilket behandlas i lektionen om chunking.

För det andra, till skillnad från vissa andra API:er, skiljer inte mistral-embed mellan query och document: det finns ingen inmatningstyp, du skickar helt enkelt texten. I praktiken går användarfrågor och indexerade dokument genom samma anrop med samma parametrar, vilket förenklar din sökkod.

Den tredje punkten är kostnad: inbäddningar faktureras per token. Att koda tusen dokument ett och ett kostar lika mycket i tokens som att koda dem i en batch, men det multiplicerar nätverksrundgångar och bearbetningstid; du optimerar genom att batcha anrop, vilket är ämnet för nästa lektion om batchning. Slutligen arbetar determinism till din fördel: för samma text returnerar modellen alltid samma vektor. Du kan därför cacha inbäddningar efter texthash och bara koda om det som faktiskt har ändrats mellan två versioner av ett dokument.

Viktiga punkter

  • mistral-embed producerar 1024-dimensionella vektorer för valfri text
  • API:t accepterar en lista med inmatningar och returnerar motsvarande vektorer
  • Vektorer är listor med flyttal, lätt konverterbara till NumPy-arrayer
  • Lagra dina inbäddningar som en NumPy-matris för likhetsberäkningar
  • Kom ihåg att dela upp långa texter innan kodning