Open-Source Embeddings: Self-Hosted Alternatives

Descripción de la cápsula

Más allá de OpenAI, existen excelentes modelos open-source de embeddings que puedes ejecutar localmente: Sentence-BERT (SBERT), BGE Models, Instructor Embeddings, y E5. Estos modelos ofrecen costo $0 por query (después de infraestructura), latencia ultra-baja (<20ms local), y control total.

En esta cápsula aprenderás los modelos open-source principales, cómo usarlos con HuggingFace Sentence-Transformers, sus ventajas/desventajas vs OpenAI, y cuándo self-hosting hace sentido. También verás código práctico para ejecutar modelos localmente.

Al final, podrás elegir entre API (OpenAI) y self-hosted (open-source) según tu caso de uso.

Landscape de open-source embeddings

Modelos principales (2026):

Top pick: BGE models (mejor MTEB/performance).

Sentence-BERT (SBERT)

Qué es:

Framework para generar sentence embeddings usando BERT-based models. Pionero de embeddings de calidad para semantic search (2019).

Desarrollado por: UKP Lab (TU Darmstadt)

Modelos populares:

1. all-MiniLM-L6-v2 (lightweight)

Dimensiones: 384
MTEB Score: ~56
Tamaño: 80 MB
Speed: ~5ms (CPU), ~1ms (GPU)
Uso: MVP, prototipado, demos

2. all-mpnet-base-v2 (balanced)

Dimensiones: 768
MTEB Score: ~58
Tamaño: 420 MB
Speed: ~15ms (CPU), ~3ms (GPU)
Uso: General purpose, production ligera

Instalación:

pip install sentence-transformers

Código básico:

from sentence_transformers import SentenceTransformer
import numpy as np

# Cargar modelo
model = SentenceTransformer('all-MiniLM-L6-v2')

# Generar embeddings
texts = [
    "Python es un lenguaje de programación",
    "JavaScript es un lenguaje web",
    "El gato duerme en el sofá"
]

embeddings = model.encode(texts)

print(f"Modelo: all-MiniLM-L6-v2")
print(f"Embeddings shape: {embeddings.shape}")  # (3, 384)
print(f"Tipo: {type(embeddings)}")  # numpy.ndarray

# Calcular similaridad
def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

sim = cosine_similarity(embeddings[0], embeddings[1])
print(f"\nSimilarity (Python vs JavaScript): {sim:.4f}")

Output:

Modelo: all-MiniLM-L6-v2
Embeddings shape: (3, 384)
Tipo: <class 'numpy.ndarray'>

Similarity (Python vs JavaScript): 0.7234

Ventajas de SBERT:

✅ 1. Costo $0 por query

# Solo pagas por GPU/CPU (fijo por mes)
# No hay costo por query (vs OpenAI $0.02/1M tokens)

✅ 2. Latencia ultra-baja

# Local CPU: ~5ms
# Local GPU: ~1ms
# vs OpenAI API: ~100ms

✅ 3. Sin límites de rate

# OpenAI: 500 RPM (tier 1)
# Self-hosted: Sin límites (solo hardware)

✅ 4. Privacidad total

# Datos NO salen de tu infraestructura
# Crítico para GDPR, HIPAA, etc.

Desventajas de SBERT:

❌ 1. Requiere infraestructura

# Necesitas GPU ($200-$500/mes en cloud)
# O CPU (más lento)

❌ 2. Maintenance

# Actualizar modelos, monitorear, escalar
# OpenAI: Zero maintenance

❌ 3. Performance ligeramente inferior

# MTEB ~56-58 (SBERT)
# vs MTEB ~62-64 (OpenAI, BGE)

BGE Models (BAAI)

Qué es:

Estado del arte en open-source embeddings (2023). Desarrollado por Beijing Academy of Artificial Intelligence (BAAI). Compite con OpenAI en MTEB.

Modelos:

1. bge-small-en-v1.5

Dimensiones: 384
MTEB Score: ~62
Tamaño: 120 MB
Speed: ~8ms (CPU), ~2ms (GPU)
Uso: Self-hosted RAG (budget-friendly)

2. bge-base-en-v1.5

Dimensiones: 768
MTEB Score: ~63
Tamaño: 430 MB
Speed: ~15ms (CPU), ~4ms (GPU)
Uso: Production estándar

3. bge-large-en-v1.5

Dimensiones: 1024
MTEB Score: ~64
Tamaño: 1.2 GB
Speed: ~30ms (CPU), ~8ms (GPU)
Uso: Máxima precisión (self-hosted)

Código básico:

from sentence_transformers import SentenceTransformer

# Cargar BGE model
model = SentenceTransformer('BAAI/bge-large-en-v1.5')

# Generar embeddings
texts = [
    "Python es un lenguaje de programación",
    "JavaScript es un lenguaje web"
]

embeddings = model.encode(texts, normalize_embeddings=True)

print(f"Modelo: BGE-large-en-v1.5")
print(f"Shape: {embeddings.shape}")  # (2, 1024)
print(f"Normalized: {np.linalg.norm(embeddings[0]):.4f}")  # ~1.0

Por qué BGE domina:

✅ 1. Performance top-tier (MTEB ~64)

# Compite con OpenAI text-embedding-3-large
# Pero $0/query después de setup

✅ 2. Entrenamiento con instrucciones

# BGE fue entrenado con queries + passages
# Mejor para retrieval (RAG)

✅ 3. Optimizado para semantic search

# Específicamente diseñado para búsqueda
# No solo similaridad general

Instructor Embeddings

Qué es:

Embeddings con instrucciones explícitas. Puedes decirle al modelo qué tarea va a hacer (retrieval, classification, clustering).

Código con instrucciones:

from InstructorEmbedding import INSTRUCTOR

# Cargar modelo
model = INSTRUCTOR('hkunlp/instructor-large')

# Embeddings CON instrucciones
query_emb = model.encode([
    ["Represent the question for retrieving supporting documents: ",
     "How to install Python?"]
])[0]

doc_emb = model.encode([
    ["Represent the document for retrieval: ",
     "To install Python, download from python.org"]
])[0]

# Calcular similaridad
similarity = np.dot(query_emb, doc_emb)
print(f"Similarity: {similarity:.4f}")

Ventaja: Embeddings especializados por tarea (retrieval query vs document).

E5 Models (Microsoft)

Qué es:

Embeddings de Microsoft (2022-2023). Competitivos con BGE. Entrenados con contrastive learning.

Modelos:

e5-small-v2:  MTEB ~60
e5-base-v2:   MTEB ~62
e5-large-v2:  MTEB ~64

Uso similar a BGE:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('intfloat/e5-large-v2')
embeddings = model.encode(texts)

Comparación: OpenAI vs Open-Source

Tabla comparativa:

Break-even analysis:

# Assumptions:
# - OpenAI 3-large: $0.13/1M tokens
# - Self-hosted GPU: $200/mes (cloud)
# - Queries/mes: X

# Costo OpenAI (X queries, 50 tokens/query):
cost_openai = (X * 50 / 1_000_000) * 0.13

# Break-even:
# cost_openai = $200
# X * 50 * 0.13 / 1_000_000 = 200
# X = 30.8M queries/mes

print("Break-even: ~31M queries/mes")
print("Si <31M queries → OpenAI")
print("Si >31M queries → Self-hosted")

Cuándo usar open-source

Self-hosted hace sentido cuando:

✅ 1. High volume (>10M queries/mes)

# Break-even a los 31M queries
# Pero savings empiezan antes

✅ 2. Privacidad crítica (GDPR, HIPAA)

# Datos NO pueden salir de tu infraestructura

✅ 3. Latencia ultra-baja requerida (<20ms)

# GPU local: ~8ms
# OpenAI API: ~100ms

✅ 4. Sin presupuesto para APIs

# Startups sin funding
# Solo tienes GPU (ya pagada)

OpenAI hace sentido cuando:

✅ 1. Low-to-medium volume (<10M queries/mes)

# Costo total <$200/mes
# No justifica self-hosting

✅ 2. Zero maintenance requerido

# No tienes DevOps team
# OpenAI maneja todo

✅ 3. Prototipado rápido

# API key → código funciona
# vs Self-hosting: Docker, GPU, monitoring

Ejercicios

Ejercicio 1: Usar SBERT

Instala sentence-transformers y genera embeddings con all-MiniLM-L6-v2:

# Instala:
# pip install sentence-transformers

# Implementa:
# 1. Cargar modelo
# 2. Generar embeddings para ["Python", "Java", "Gato"]
# 3. Calcular similaridad Python vs Java

from sentence_transformers import SentenceTransformer
import numpy as np

# Cargar modelo
model = SentenceTransformer('all-MiniLM-L6-v2')

# Generar embeddings
texts = ["Python", "Java", "Gato"]
embeddings = model.encode(texts)

print(f"Shape: {embeddings.shape}")  # (3, 384)

# Similaridad Python vs Java
def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

sim = cosine_similarity(embeddings[0], embeddings[1])
print(f"Python vs Java: {sim:.4f}")  # ~0.75

sim_cat = cosine_similarity(embeddings[0], embeddings[2])
print(f"Python vs Gato: {sim_cat:.4f}")  # ~0.45

Ejercicio 2: Comparar OpenAI vs SBERT

Compara embeddings de ambos para el mismo texto:

# 1. Generar embedding con OpenAI (3-small)
# 2. Generar embedding con SBERT (all-MiniLM-L6-v2)
# 3. ¿Son similares? (hint: diferentes dimensiones, no directamente comparable)

from openai import OpenAI
from sentence_transformers import SentenceTransformer
import os
from dotenv import load_dotenv

load_dotenv()
client_openai = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

text = "Python es popular"

# OpenAI
emb_openai = client_openai.embeddings.create(
    model="text-embedding-3-small",
    input=text
).data[0].embedding

# SBERT
model_sbert = SentenceTransformer('all-MiniLM-L6-v2')
emb_sbert = model_sbert.encode([text])[0]

print(f"OpenAI dims: {len(emb_openai)}")  # 1536
print(f"SBERT dims: {len(emb_sbert)}")    # 384

# No podemos comparar directamente (diferentes dimensiones)
# Pero ambos capturan semántica de "Python es popular"

Resumen

Qué aprendiste:

• ✅ Open-source landscape: SBERT, BGE, Instructor, E5
• ✅ BGE domina: MTEB ~64 (igual que OpenAI 3-large)
• ✅ Ventajas self-hosted: $0/query, latencia <20ms, privacidad
• ✅ Desventajas: Requiere infra, maintenance
• ✅ Break-even: ~31M queries/mes

Conceptos clave:

1. BGE-large-en-v1.5 → Mejor open-source (MTEB 64)
2. Self-hosted → High volume, privacidad, latencia
3. OpenAI → Low volume, zero maintenance

Recursos adicionales

1. Sentence-Transformers Docs - SBERT oficial
2. BGE GitHub - Código y modelos
3. Instructor Embeddings - Repo oficial
4. HuggingFace Model Hub - Modelos pre-entrenados

En la siguiente cápsula

Cápsula 04: MTEB Benchmark

Aprenderás:

• Qué es MTEB (Massive Text Embedding Benchmark)
• Cómo interpretar scores
• Limitaciones de benchmarks
• Ejecutar MTEB en tus modelos

De modelos a evaluación sistemática.

Módulo 3 - Embeddings Deep Dive Guide Open-source embeddings: alternativas self-hosted de calidad