Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

A mistral-embed modell

2. lecke 18 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. A mistral-embed áttekintése
  2. Beállítás és telepítés
  3. Beágyazások generálása
  4. Az API-válasz felépítése
  5. Teljes példa: Kódolás és tárolás
  6. Korlátok és legjobb gyakorlatok
  7. Főbb megállapítások

A mistral-embed áttekintése

A mistral-embed a Mistral AI szöveges beágyazási (embedding) modellje. Bármilyen szöveget 1024 dimenziós vektortá alakít, függetlenül a bemenet hosszától – legyen szó egy rövid mondatról vagy egy teljes bekezdésről, a kimeneti vektor mérete mindig ugyanakkora. Ez a rögzített dimenziószám nem apróság: lehetővé teszi, hogy egy termék címét és teljes leírását ugyanabban a vektortérben indexeld, majd közvetlenül összehasonlítsd őket anélkül, hogy speciális lépéseket kellene tenned a különböző formátumok összeegyeztetésére.

Ezt a modellt szemantikai kereséshez, osztályozáshoz és klaszterezéshez optimalizálták természetes nyelvű szövegeken (cikkek, dokumentumok, beszélgetések és egyebek). Használd tudásbázisok, GYIK oldalak, értekezleti jegyzőkönyvek vagy akár egy évtizednyi ügyfélszolgálati jegy indexelésére.

Beállítás és telepítés

Mielőtt hívnád az API-t, telepítsd a Mistral Python SDK-t és állítsd be az API-kulcsodat:

# 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)

Az API-kulcsodat a Mistral konzolból szerezheted be. Tárold környezetváltozóban, hogy ne kerüljön bele a kódodba. Az os.environ.get használata nem csupán elméleti higiénia: megakadályozza, hogy a kulcsod bekerüljön a Git előzményeibe azon a napon, amikor a projekted nyilvánossá válik.

Beágyazások generálása

Az API-hívás egyszerű: adj át egy szövegek listáját, és kérdezd le a hozzájuk tartozó vektorokat. Ne feledd, hogy még egyetlen szöveg esetén is listának kell lennie a bemenetnek – az API mindig kötegekben (batch) dolgozik, ami akkor térül meg igazán, ha a korpuszod növekszik.

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]}")

Tipikus kimenet:

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]

Az API-válasz felépítése

A válasz többet tartalmaz, mint pusztán a vektorokat. Megadja azt is, melyik modellt használták valójában, és hány tokent fogyasztott el – ez a két információ fontos lesz, ha éles környezetben fut a kódolás, és valakinek meg kell magyaráznia a számlát. Fordíts különös figyelmet az index mezőre: ez jelzi a szöveg pozícióját az elküldött listában, így vissza tudod vezetni minden vektort a forrásdokumentumához.

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]

Teljes példa: Kódolás és tárolás

Íme egy tipikus folyamat dokumentumkorpusz kódolására és a vektorok előkészítésére a későbbi kereséshez. A NumPy-re való váltás a kritikus lépés: amíg a vektoraid Python listák, addig minden hasonlósági számítás elemről elemre történik; ha viszont mátrixot építesz, egyetlen művelettel összehasonlíthatod a lekérdezést a teljes korpuszszal.

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)

A .npy formátumban való mentés elkerüli, hogy minden alkalmazás-indításkor újra kelljen fizetned a kódolásért. Több ezer dokumentumból álló korpusz esetén ez a különbség a pillanatszerű indulás és a több perces, számlázott API-hívások között.

Korlátok és legjobb gyakorlatok

Négy tényező határozza meg az eredményeid minőségét. Először is a maximális hossz: a modell levágja a túl hosszú szövegeket, és ez a vágás csendben történik – egy negyven oldalas jelentés, amelyet egyben kódolsz be, gyakorlatilag csak az elejét fogja reprezentálni. Részesítsd előnyben az 512 és 2048 token közötti darabokat (chunkokat), amit a darabolásról szóló leckében részletezünk.

Másodszor, ellentétben néhány egyéb API-val, a mistral-embed nem tesz különbséget a query (lekérdezés) és a document (dokumentum) között: nincs bemeneti típus, egyszerűen csak átadod a szöveget. A gyakorlatban a felhasználói kérdések és az indexelt dokumentumok ugyanazzal a hívással és ugyanazokkal a paraméterekkel mennek keresztül, ami leegyszerűsíti a keresési kódodat.

A harmadik pont a költség: a beágyazásokat tokentenként számlázzák. Ezer dokumentum egyesével történő kódolása tokenekben ugyanannyiba kerül, mint kötegben, de megsokszorozza a hálózati köröket és a feldolgozási időt; a hívások kötegelésével optimalizálsz, ami a következő, kötegelésről szóló lecke témája. Végül a determinizmus a javadra válik: ugyanarra a szövegre a modell mindig ugyanazt a vektort adja vissza. Ezért gyorsítótárazhatod a beágyazásokat a szöveg hash-értéke alapján, és csak azt kell újra kódolnod, ami ténylegesen megváltozott a dokumentum két verziója között.

Főbb megállapítások

  • A mistral-embed bármilyen szöveghez 1024 dimenziós vektorokat állít elő
  • Az API bemeneti listát fogad el, és a hozzájuk tartozó vektorokat adja vissza
  • A vektorok lebegőpontos számok listái, amelyek könnyen alakíthatók NumPy tömbökké
  • A hasonlósági számításokhoz NumPy mátrixként tárold a beágyazásaidat
  • Ne felejtsd el feldarabolni a hosszú szövegeket kódolás előtt