AI-körning och modellserver · Embeddings och omrankning
Serveringsmotor för embeddings, omrankning och klassificering över HTTP och gRPC – ingen textgenerering eller chatt.
Betyg 83 av 100 Preliminär (källbaserad)
Läs bedömningenServern svarar på POST /embed och /rerank samt på OpenAI-kompatibla anrop under /v1/embeddings; modellen anges när tjänsten startas.
Källa: https://huggingface.co/docs/text-embeddings-inference/quick_tour
Kontrollerat:
Text Embeddings Inference är en inferensserver för embeddings; projektet har ingen MCP-server och någon sådan finns inte i dokumentationen.
Källa: https://huggingface.co/docs/text-embeddings-inference/quick_tour
Kontrollerat:
Totalbetyg
83 av 100
Preliminär (källbaserad)
Apache-2.0 verifierat i repots LICENSE-fil ('Apache License, Version 2.0, January 2004'), en OSI-godkänd licens utan open-core-uppdelning: repo-trädet (340 filer) har ingen ee/-katalog och hela servern — Rust-router, protobuf-definition, Dockerfile-varianter och dokumentation — ligger öppet. Friheten att läsa, ändra och återdistribuera är dokumenterad och oinskränkt, och drift är helt fri: egen container, egen kompilering från källkod eller Homebrew-binär, ingen kontakt med Hugging Face krävs vid körning eftersom modellvikter kan monteras som volym (README:s avsnitt 'Air gapped deployment'). Formaten är öppna standarder: safetensors och ONNX för vikter, JSON över HTTP, protobuf över gRPC. Det enda förbehållet är att de modeller man serverar har egna licenser (t.ex. är embeddinggemma-300m gated), men det gäller modellvikterna, inte produkten. Nivå 5 är därför entydigt uppfyllt.
Användningsfallet täcks väl: README beskriver servering av embeddings- och sekvensklassificeringsmodeller med endpoints /embed, /rerank, /predict och /embed_sparse, tokenbaserad dynamisk batchning, ingen kompileringsfas för modellgrafen, små images med snabb starttid samt produktionsfunktioner som Prometheus-metrics och distribuerad spårning via OpenTelemetry. Modellstödet är brett och namngivet: BERT, CamemBERT, XLM-RoBERTa, Nomic, JinaBERT, Mistral, Alibaba GTE, Qwen2, Qwen3, MPNet, ModernBERT och Gemma3, inklusive flerspråkiga modeller som intfloat/multilingual-e5-large-instruct. Luckorna är kända och delvis avsiktliga: modellstöd begränsat till de arkitekturer som listas (andra embeddingsmodeller kan inte laddas), ingen textgenerering eller chatt, ingen agentfunktion, inget grafiskt gränssnitt. Eftersom användningsfallet är en byggsten under sök/RAG och inte en komplett app är luckorna mindre allvarliga, men arkitekturbegränsningen är en verklig lucka som kräver att man väljer modell efter TEI snarare än tvärtom — därför 4, inte 5.
Gränssnittet är fullständigt och maskinläsbart dokumenterat: docs/openapi.json i repot är en OpenAPI 3.0.3-specifikation märkt version 1.9.4 som listar /embed, /embed_all, /embed_sparse, /rerank, /predict, /similarity, /decode, /tokenize, /info, /health, /metrics och /v1/embeddings, och samma schema serveras på instansens /docs och publiceras på huggingface.github.io/text-embeddings-inference. Därtill finns ett publicerat gRPC-API med protobuf-definition i proto/tei.proto och images med -grpc-tagg. In- och utdata är standardiserade: JSON över HTTP, protobuf över gRPC, vikter i safetensors eller ONNX. Det finns ingen inlåsning i data — tjänsten är stateless och producerar vektorer som konsumeras av vilket system som helst, vilket är precis vad nivå 5 avser ('väldokumenterat API med standarder').
Projektet förvaltas av Hugging Face och har etablerad historik: releases.atom visar v1.9.4 (2026-09-15), v1.9.3 (2026-03-23), v1.9.2 (2026-02-25), v1.9.1 (2026-02-17) och v1.9.0 (2026-02-17) — alltså versionsnumrerade utgåvor över tid, inte betor. Dokumentationen är strukturerad under docs/source/en med egna sidor för supported_models, cli_arguments, local_gpu, local_cpu, local_metal, private_models, custom_container, intel_container, amd_gpu och examples, och OpenAPI-schemat versionsföljer releasen (1.9.4). Ekosystemet är tydligt: images per arkitektur på ghcr.io, Homebrew-binär för Apple Silicon, ROCm-image för AMD Instinct och referenser till Hugging Face Inference Endpoints och RAG-containers. Det motsvarar nivå 4. Det som saknas för 5 är en verifierad säkerhetspolicy (ingen SECURITY.md eller publicerad CVE-process hittad i repo-trädet) och ett uttalat LTS-/supportåtagande; dessutom är Turing- och Blackwell-images markerade som experimentella, vilket är en mognadssignal. Konfidensen är medium eftersom förvaltningen är tydlig men säkerhetsrutinerna inte kunnat beläggas.
Integrationsytan är stark och dokumenterad i maskinläsbar form: OpenAPI 3.0.3 med tolv endpoints inklusive /v1/embeddings, vilket är OpenAI-kompatibelt och gör TEI utbytbart mot kommersiella embedding-API:er utan kodändring; gRPC-API för högpresterande drift med publicerad protobuf-definition; CLI-styrning via text-embeddings-router med flaggor för batchning, pooling, API-nyckel, CORS och payload-gränser; Prometheus-metrics på egen port och OpenTelemetry via --otlp-endpoint, dvs. det går att koppla in i övervakning och automation utan egen kod. Arkitekturen är modern och modulär (Rust, Candle, Flash Attention, valbar ONNX- eller Metal-backend). Det som håller kvar på 4 och inte 5 är att TEI inte har någon egen agentintegration eller MCP — det är en tjänst andra system anropar, inte en agentplattform — och att modellstödet kräver att man väljer bland listade arkitekturer, vilket begränsar anpassningsförmågan. Konfidensen är medium eftersom endpointlistan är verifierad men jag inte kunnat belägga hur väl /v1/embeddings-svaret matchar OpenAI-specifikationen i detalj (fältnamn, dimensionsparameter).
Införandet är litet och väldokumenterat: en enda container startas med docker run, modellen anges med --model-id (antingen ett Hugging Face-ID eller en lokal katalog) och vikter kan monteras som volym så att de inte laddas ner varje körning. README innehåller en explicit tabell över vilken image som hör till vilken arkitektur (cpu, cpu-arm64, turing, 80/86/89, hopper, 100/120/121, rocm) samt krav på NVIDIA Container Toolkit och CUDA 12.2+. Löpande drift är enkel: ny image, samma flaggor, ingen databas och ingen migrering att hantera eftersom tjänsten är stateless. Det motsvarar nivå 4. Friktionen som drar ner från 5 är att GPU-imagen måste matcha grafikkortets beräkningskapacitet — ett steg som kräver att man känner till compute capability — att Turing- och Blackwell-images är experimentella, att compute capability under 7.5 inte stöds (V100 och GTX 1000-serien) och att allt styrs via kommandoradsflaggor utan administrationsgränssnitt. Konfidensen är medium eftersom jag läst README och CLI-hjälpen men inte själv startat en image på GPU.
Licenskostnaden är noll och helt transparent (Apache-2.0, ingen avgift, ingen hosted version att prenumerera på), och det finns ingen publik prislista att förhandla mot eftersom inget säljs. TCO-antagandena för användningsfallet är ändå tunga: (1) hårdvara — README:s prestandasiffror är mätta på ett NVIDIA A10 med sekvenslängd 512, så en realistisk GPU-instans är den dominerande kostnaden och den måste beräknas lokalt (inköp eller moln-GPU-tid); CPU-images fungerar men prestandan blir en annan och kan kräva mer kapacitet; (2) drift — en container utan databas, låg löpande kostnad men kräver GPU-drivrutiner och NVIDIA Container Toolkit; (3) arbetstid — engångsarbete med imageval och batchning, sedan litet. Kostnadsbilden är alltså tydlig på licens- och driftssidan men den stora posten (GPU) kräver egen beräkning, vilket är exakt nivå 3 ('vissa kostnader kräver egen beräkning'). Konfidensen är medium eftersom ingen faktisk GPU-kostnad är verifierad och jag inte kunnat jämföra CPU- mot GPU-drift i praktiken.
Negativ kontroll utförd: jag hämtade hela repo-trädet för huggingface/text-embeddings-inference (340 filer) och sökte efter lokaliseringskataloger och i18n — resultatet är att det inte finns någon locale- eller i18n-katalog. Dokumentationsträdet innehåller enbart docs/source/en (index, supported_models, cli_arguments, local_gpu, local_cpu, local_metal, amd_gpu, private_models, custom_container, examples m.fl.) och ingen annan språkkatalog, dvs. ingen svensk dokumentation finns att mäta andel nycklar mot. Produkten har dessutom inget grafisk gränssnitt att lokalisera — allt styrs via HTTP/gRPC och CLI-flaggor — så det finns ingen svensk gränssnittsöversättning att verifiera. Nivå 1: verifierat svagt svenskt stöd, engelskspråkig men tekniskt användbar i Sverige. Konfidensen är medium eftersom avsaknaden av språkkatalog är entydig, men svensk text kan förstås och sökas eftersom README listar flerspråkiga embeddingmodeller (t.ex. intfloat/multilingual-e5-large-instruct och XLM-RoBERTa) — det är modellernas språkförmåga, inte TEI:s lokalisering, och jag har inte gjort något svenskt sök- eller embeddingtest som skulle kunna belägga svensk språkförmåga i praktiken.
## Vad det gör
Text Embeddings Inference (TEI) är Hugging Faces verktyg för att driftsätta och servera öppna embeddingsmodeller och sekvensklassificeringsmodeller. Den producerar vektorer för textsökning och RAG, serverar omrankningsmodeller som poängsätter hur väl en text passar en fråga och kan köra klassificeringsmodeller. Stödda modellfamiljer är bland andra BERT, XLM-RoBERTa, GTE, Qwen3 och ModernBERT. TEI genererar ingen text och har ingen chattfunktion – den är en byggsten under en söktjänst eller RAG-pipeline.
## Driftsättning
Tjänsten startas som container med en image som matchar hårdvaran: cpu-1.9 för CPU, cuda-1.9 för Ampere, 86-1.9 för A10 och A40 och 89-1.9 för RTX 4000-serien. Modellen anges med --model-id och kan vara ett modell-ID från Hugging Face eller en lokal katalog – då kan vikterna monteras som volym och tjänsten köras luftgapad. Servern svarar på /embed, /rerank, /predict och /embed_sparse med OpenAPI på /docs.
## Vad som krävs
För GPU krävs NVIDIA Container Toolkit, drivrutiner för CUDA 12.2 eller senare och beräkningskapacitet 7.5 eller högre; V100 och GTX 1000-serien stöds inte. AMD Instinct via ROCm och Apple Silicon via Metal-binär stöds också.
4 skärmbilder. Välj en bild för att visa den i full storlek. Svep i sidled för fler.
AI-körning och modellserver · Inferensmotor för stora språkmodeller (lokal körning)
llama.cpp är en MIT-licensierad inferensmotor för kvantiserade språkmodeller i GGUF-format som kör på CPU och GPU, med kommandoradsverktyg och en OpenAI-kompatibel server.
Ollama är ett verktyg för att hämta och köra öppna språkmodeller lokalt eller i egen molnmiljö: CLI, lokal HTTP-API och ett modellbibliotek med pull-by-name. Koden licensieras MIT.
