Przejdź do głównej treści
Polski— Wybierz język
Menu

Model mistral-embed

Lekcja 2 z 18 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Przegląd modelu mistral-embed
  2. Konfiguracja i instalacja
  3. Generowanie osadzeń (Embeddings)
  4. Struktura odpowiedzi API
  5. Kompletny przykład: Kodowanie i zapisywanie
  6. Limity i najlepsze praktyki
  7. Kluczowe wnioski

Przegląd modelu mistral-embed

mistral-embed to model osadzania tekstu (text embedding) od Mistral AI. Przekształca dowolny tekst w wektor o wymiarowości 1024, niezależnie od długości wejścia – czy to krótkie zdanie, czy cały akapit, wynikowy wektor zawsze ma ten sam rozmiar. Ta stała wymiarowość to nie drobiazg: pozwala indeksować zarówno tytuł produktu, jak i jego pełny opis w tej samej przestrzeni wektorowej, a następnie porównywać je bezpośrednio bez żadnego specjalnego przetwarzania w celu uzgodnienia różnych formatów.

Model ten jest zoptymalizowany pod kątem wyszukiwania semantycznego, klasyfikacji i klasteryzacji tekstów w języku naturalnym (artykuły, dokumenty, rozmowy i inne). Wykorzystaj go do indeksowania bazy wiedzy, FAQ, transkryptów spotkań lub dziesięcioletniej historii zgłoszeń wsparcia technicznego.

Konfiguracja i instalacja

Zanim wywołasz API, zainstaluj Python SDK od Mistral i skonfiguruj swój klucz API:

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

Pobierz swój klucz API z konsoli Mistral. Przechowuj go w zmiennej środowiskowej, aby nie znalazł się w kodzie. Odczyt przez os.environ.get to nie tylko teoretyczna higiena: zapobiega sytuacji, w której Twój klucz trafi do migawki historii Git w dniu, w którym Twój projekt stanie się publiczny.

Generowanie osadzeń (Embeddings)

Wywołanie API jest proste: przekaż listę tekstów i pobierz odpowiadające im wektory. Pamiętaj, że nawet dla pojedynczego tekstu dane wejściowe muszą być listą – API zawsze pracuje w partiach (batchach), co opłaca się natychmiast, gdy tylko Twój korpus danych urośnie.

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

Typowy wynik:

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]

Struktura odpowiedzi API

Odpowiedź zawiera więcej niż same wektory. Informuje również, którego modelu faktycznie użyto i ile tokenów zużyto – to dwie informacje, które będziesz chciał logować, gdy kodowanie zacznie działać w środowisku produkcyjnym i ktoś będzie musiał wyjaśnić rachunek. Zwróć szczególną uwagę na pole index: wskazuje ono pozycję tekstu na liście, którą wysłałeś, co pozwala odwzorować każdy wektor z powrotem do jego źródłowego dokumentu.

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]

Kompletny przykład: Kodowanie i zapisywanie

Oto typowy potok (pipeline) do kodowania korpusu dokumentów i przygotowania wektorów do późniejszego wyszukiwania. Przejście na NumPy jest kluczowym krokiem: dopóki Twoje wektory są listami Pythona, każde obliczenie podobieństwa odbywa się element po elemencie; gdy tylko zbudujesz macierz, pojedyncza operacja porównuje zapytanie z całym korpusem.

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)

Zapisywanie jako .npy pozwala uniknąć płacenia za ponowne kodowanie przy każdym restartie aplikacji. Przy korpusie liczącym kilka tysięcy dokumentów jest to różnica między natychmiastowym uruchomieniem a kilkoma minutami płatnych wywołań API.

Limity i najlepsze praktyki

Cztery czynniki decydują o jakości Twoich wyników. Po pierwsze, maksymalna długość: model ucina teksty, które są zbyt długie, a ucina je po cichu – czterdziestostronicowy raport zakodowany jako jeden blok będzie efektywnie reprezentował tylko swój początek. Preferuj fragmenty (chunki) o wielkości od 512 do 2048 tokenów, co omówiono w lekcji dotyczącej dzielenia na fragmenty.

Po drugie, w przeciwieństwie do niektórych innych API, mistral-embed nie rozróżnia między query a document: nie ma typu wejścia, po prostu przekazujesz tekst. W praktyce pytania użytkowników i indeksowane dokumenty przechodzą przez to samo wywołanie z tymi samymi parametrami, co upraszcza Twój kod wyszukiwania.

Trzecim punktem jest koszt: osadzenia są rozliczane za token. Kodowanie tysiąca dokumentów pojedynczo kosztuje tyle samo tokenów, co kodowanie ich w partii, ale mnoży liczbę rund sieciowych i czas przetwarzania; optymalizujesz to, grupując wywołania, co jest tematem następnej lekcji o batchingu. Wreszcie, determinizm działa na Twoją korzyść: dla tego samego tekstu model zawsze zwraca ten sam wektor. Możesz więc buforować osadzenia według hasha tekstu i kodować ponownie tylko to, co faktycznie zmieniło się między dwiema wersjami dokumentu.

Kluczowe wnioski

  • mistral-embed generuje wektory o wymiarowości 1024 dla dowolnego tekstu
  • API przyjmuje listę danych wejściowych i zwraca odpowiadające im wektory
  • Wektory to listy liczb zmiennoprzecinkowych, które łatwo przekonwertować na tablice NumPy
  • Przechowuj swoje osadzenia jako macierz NumPy do obliczeń podobieństwa
  • Pamiętaj o podziale długich tekstów przed kodowaniem