Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Het mistral-embed-model

Les 2 van 18 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Overzicht van mistral-embed
  2. Installatie en configuratie
  3. Embeddings genereren
  4. Structuur van het API-antwoord
  5. Volledig voorbeeld: coderen en opslaan
  6. Limieten en best practices
  7. Belangrijkste punten

Overzicht van mistral-embed

mistral-embed is het tekst-embeddingmodel van Mistral AI. Het zet elke tekst om in een 1024-dimensionale vector, ongeacht de invoerlengte—of het nu een korte zin of een hele alinea is, de uitvoervector heeft altijd dezelfde grootte. Deze vaste dimensionaliteit is geen klein detail: hiermee kunt u zowel een producttitel als de volledige beschrijving indexeren in dezelfde vectorruimte en ze vervolgens direct vergelijken zonder speciale verwerking om verschillende formaten op elkaar af te stemmen.

Dit model is geoptimaliseerd voor taken op het gebied van semantisch zoeken, classificatie en clustering van natuurlijke taalteksten (artikelen, documenten, gesprekken, en meer). Gebruik het om een kennisbank, veelgestelde vragen (FAQ), vergadertranscripties of een decennium aan supporttickets te indexeren.

Installatie en configuratie

Voordat u de API aanroept, installeert u de Mistral Python SDK en configureert u uw API-sleutel:

# Installation
# pip install mistralai

import os
from mistralai.client import Mistral

# Initialize the client
api_key = os.environ.get("MISTRAL_API_KEY")
client = Mistral(api_key=api_key)

Haal uw API-sleutel op via de Mistral-console. Sla deze op in een omgevingsvariabele om deze uit uw code te houden. Uitlezen via os.environ.get is niet slechts theoretische hygiëne: het voorkomt dat uw sleutel in een Git-historiesnapshot belandt op de dag dat uw project openbaar wordt.

Embeddings genereren

De API-aanroep is eenvoudig: geef een lijst met teksten door en haal de bijbehorende vectoren op. Merk op dat de invoer zelfs voor één enkele tekst een lijst moet zijn—de API werkt altijd in batches, wat zijn vruchten afwerpt zodra uw corpus groeit.

from mistralai.client import Mistral

client = Mistral(api_key=api_key)

# Generate embeddings for one or more texts
response = client.embeddings.create(
    model="mistral-embed",
    inputs=[
        "Embeddings capture semantic meaning.",
        "Mistral AI offers high-performance models.",
        "RAG improves response quality."
    ],
)

# Access the vectors
for i, data in enumerate(response.data):
    print(f"Text {i+1}: vector of {len(data.embedding)} dimensions")
    print(f"  First elements: {data.embedding[:5]}")

Typische uitvoer:

Text 1: vector of 1024 dimensions
  First elements: [0.0234, -0.1567, 0.0891, 0.0123, -0.0456]
Text 2: vector of 1024 dimensions
  First elements: [0.0189, -0.1234, 0.0678, 0.0345, -0.0567]
Text 3: vector of 1024 dimensions
  First elements: [0.0312, -0.1456, 0.0789, 0.0234, -0.0345]

Structuur van het API-antwoord

Het antwoord bevat meer dan alleen vectoren. Het vertelt u ook welk model daadwerkelijk is gebruikt en hoeveel tokens er zijn verbruikt—twee gegevens die u wilt loggen zodra codering in productie draait en iemand de factuur moet verklaren. Besteed bijzondere aandacht aan het veld index: dit geeft de positie van de tekst in de verzonden lijst aan, zodat u elke vector kunt koppelen aan het brondocument.

response = client.embeddings.create(
    model="mistral-embed",
    inputs=["Example text to encode."],
)

# Response object
print(response.model)          # "mistral-embed"
print(response.usage)          # tokens consumed

# Embedding data
embedding_data = response.data[0]
print(embedding_data.index)     # 0 (position in the inputs list)
print(len(embedding_data.embedding))  # 1024
print(type(embedding_data.embedding))  # list[float]

Volledig voorbeeld: coderen en opslaan

Hier ziet u een typische pipeline voor het coderen van een documentcorpus en het voorbereiden van vectoren voor later zoeken. De overstap naar NumPy is de cruciale stap: zolang uw vectoren Python-lijsten zijn, gebeurt elke similariteitsberekening element voor element; zodra u een matrix bouwt, vergelijkt één enkele operatie de query met het volledige corpus.

import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

# Document corpus
documents = [
    "Mistral AI is a French artificial intelligence company.",
    "RAG combines information retrieval and text generation.",
    "Embeddings enable semantic search.",
    "Python is the most widely used language in data science.",
    "FAISS is a vector search library by Meta.",
]

# Encode all documents
response = client.embeddings.create(
    model="mistral-embed",
    inputs=documents,
)

# Convert to a NumPy matrix for calculations
embeddings_matrix = np.array([d.embedding for d in response.data])

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

# Save for later use
np.save("document_embeddings.npy", embeddings_matrix)

Opslaan als .npy voorkomt dat u betaalt om bij elke herstart van uw applicatie opnieuw te coderen. Bij een corpus van enkele duizenden documenten is dit het verschil tussen direct opstarten en enkele minuten aan gefactureerde API-aanroepen.

Limieten en best practices

Vier factoren bepalen de kwaliteit van uw resultaten. Ten eerste de maximale lengte: het model kappt teksten die te lang zijn, en deze inkorting gebeurt stilzwijgend—een rapport van veertig pagina’s dat in één blok wordt gecodeerd, zal effectief alleen het begin weergeven. Geef de voorkeur aan chunks van 512 tot 2048 tokens, zoals behandeld in de les over chunking.

Ten tweede maakt mistral-embed, in tegenstelling tot sommige andere API’s, geen onderscheid tussen query en document: er is geen invoertype, u geeft gewoon de tekst door. In de praktijk gaan gebruikersvragen en geïndexeerde documenten door dezelfde aanroep met dezelfde parameters, wat uw zoekcode vereenvoudigt.

Het derde punt is kosten: embeddings worden per token gefactureerd. Het één voor één coderen van duizend documenten kost qua tokens evenveel als het in batch coderen, maar het vermenigvuldigt het aantal netwerkaanroepen en de verwerkingstijd; u optimaliseert door aanroepen te bundelen, wat het onderwerp is van de volgende les over batching. Tot slot werkt determinisme in uw voordeel: voor dezelfde tekst retourneert het model altijd dezelfde vector. U kunt daarom embeddings cachen op basis van een tekst-hash en alleen opnieuw coderen wat daadwerkelijk is gewijzigd tussen twee versies van een document.

Belangrijkste punten

  • mistral-embed produceert 1024-dimensionale vectoren voor elke tekst
  • De API accepteert een lijst met invoer en retourneert de bijbehorende vectoren
  • Vectoren zijn lijsten met floats, eenvoudig om te zetten naar NumPy-arrays
  • Sla uw embeddings op als een NumPy-matrix voor similariteitsberekeningen
  • Vergeet niet lange teksten te splitsen voordat u ze codeert