Weaviate

Weaviate es una base de datos vectorial de código abierto, nativa de IA, diseñada para búsqueda semántica, búsqueda híbrida y aplicaciones RAG (Generación Aumentada por Recuperación). Almacena tanto objetos como sus incrustaciones vectoriales y admite integración de modelos de ML incorporados.

Resumen

Weaviate va más allá de las bases de datos vectoriales tradicionales al integrar de forma nativa modelos de ML para la vectorización automática en el momento de la importación y de la consulta. Admite múltiples tipos de datos (texto, imágenes, vídeo, audio), búsqueda híbrida incorporada que combina BM25 y similitud vectorial, y despliegues multicliente. Weaviate está listo para producción, es nativo en la nube y está diseñado para escalar desde prototipos hasta miles de millones de vectores.

Propiedad	Valor
Categoría	Base de datos vectorial / Infraestructura RAG
Desarrollador	Weaviate B.V.
Licencia	BSD de 3 cláusulas
GitHub	weaviate/weaviate
Estrellas	12K+
Imagen Docker	cr.weaviate.io/semitechnologies/weaviate
Puertos	22 (SSH), 8080 (API HTTP / GraphQL)

---

Características clave

• Búsqueda híbrida vector + palabra clave — combina BM25 de texto completo con similitud vectorial en una sola consulta

• Vectorizadores integrados — vectoriza automáticamente los datos al importarlos con OpenAI, Cohere, HuggingFace o modelos locales

• Multimodal — almacena y busca texto, imágenes, vídeo y audio en una sola base de datos

• API GraphQL — lenguaje de consulta expresivo para consultas semánticas complejas

• API REST — operaciones CRUD completas y gestión de esquemas

• Multitenencia — aisla los datos por inquilino con infraestructura compartida

• Indexado HNSW — búsqueda aproximada de vecinos más cercanos rápida

• Búsqueda filtrada — combina la búsqueda vectorial con filtros tradicionales de metadatos

• Búsqueda generativa — RAG incorporado con integración de LLM

• Escalado horizontal — fragmenta y replica en múltiples nodos

• Sistema de módulos — enchufa vectorizadores, lectores, generadores

---

Configuración en Clore.ai

Paso 1 — Elegir hardware

Caso de uso	Recomendado	RAM	Almacenamiento
Desarrollo / prototipado	Instancia CPU	8 GB	20 GB
Pequeña producción (< 1M de vectores)	Instancia CPU	16 GB	50 GB
Gran escala (10M+ de vectores)	Instancia GPU	32 GB+	200 GB+
Vectorización acelerada por GPU	RTX 4090	24 GB	100 GB

Weaviate se ejecuta en CPU. Use instancias GPU en Clore.ai cuando necesite modelo de incrustación local inferencia (por ejemplo, text2vec-transformers con un modelo local) para vectorización rápida en el momento de la importación.

Paso 2 — Alquila un servidor en Clore.ai

1. Ve a clore.ai → Marketplace

2. Para búsqueda vectorial pura: instancias CPU con ≥ 16 GB de RAM

3. Para incrustaciones aceleradas por GPU: RTX 3090 o 4090

4. Puertos abiertos: 22 y 8080

5. Asegúrate ≥ 50 GB de disco para almacenamiento de vectores

Paso 3 — Desplegar con Docker

Despliegue mínimo (sin vectorizador):

docker run -d \
    --name weaviate \
    -p 8080:8080 \
    -p 50051:50051 \
    -v /opt/weaviate/data:/var/lib/weaviate \
    -e QUERY_DEFAULTS_LIMIT=20 \
    -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true \
    -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \
    -e DEFAULT_VECTORIZER_MODULE=none \
    -e ENABLE_MODULES="" \
    -e CLUSTER_HOSTNAME=node1 \
    cr.weaviate.io/semitechnologies/weaviate:latest

Con vectorizador OpenAI:

docker run -d \
    --name weaviate \
    -p 8080:8080 \
    -v /opt/weaviate/data:/var/lib/weaviate \
    -e QUERY_DEFAULTS_LIMIT=20 \
    -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true \
    -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \
    -e DEFAULT_VECTORIZER_MODULE=text2vec-openai \
    -e ENABLE_MODULES=text2vec-openai,generative-openai \
    -e OPENAI_APIKEY=<your-openai-key> \
    -e CLUSTER_HOSTNAME=node1 \
    cr.weaviate.io/semitechnologies/weaviate:latest

Con vectorizador HuggingFace local (acelerado por GPU):

# docker-compose.yml
version: '3.4'

services:
  weaviate:
    image: cr.weaviate.io/semitechnologies/weaviate:latest
    restart: unless-stopped
    ports:
      - "8080:8080"
      - "50051:50051"
    volumes:
      - /opt/weaviate/data:/var/lib/weaviate
    environment:
      QUERY_DEFAULTS_LIMIT: 20
      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true'
      PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
      DEFAULT_VECTORIZER_MODULE: text2vec-transformers
      ENABLE_MODULES: 'text2vec-transformers,generative-openai'
      TRANSFORMERS_INFERENCE_API: 'http://t2v-transformers:8080'
      CLUSTER_HOSTNAME: 'node1'

  t2v-transformers:
    image: cr.weaviate.io/semitechnologies/transformers-inference:sentence-transformers-multi-qa-MiniLM-L6-cos-v1
    environment:
      ENABLE_CUDA: '1'
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

Iniciar:

mkdir -p /opt/weaviate/data
docker-compose up -d

---

Acceder a la API

API HTTP/REST

http://<server-ip>:8080

Endpoint GraphQL

http://<server-ip>:8080/v1/graphql

Comprobación de salud

curl http://<server-ip>:8080/v1/.well-known/ready
# Devuelve: {}  (HTTP 200 = saludable)

Vía SSH

ssh root@<ip-del-servidor> -p 22

---

Cliente Python

Instalación

pip install weaviate-client

Conectar

import weaviate
import weaviate.classes as wvc

# Conéctese a su instancia Clore.ai
client = weaviate.connect_to_custom(
    http_host="<server-ip>",
    http_port=8080,
    http_secure=False,
    grpc_host="<server-ip>",
    grpc_port=50051,
    grpc_secure=False,
)

print(client.is_ready())  # True si está saludable

---

Esquema y Colecciones

Crear una Colección

import weaviate
import weaviate.classes as wvc
from weaviate.classes.config import Configure, Property, DataType

client = weaviate.connect_to_custom(
    http_host="<server-ip>", http_port=8080,
    grpc_host="<server-ip>", grpc_port=50051,
    http_secure=False, grpc_secure=False,
)

# Crear una colección (antes se llamaba "class" en la v3)
client.collections.create(
    name="Article",
    vectorizer_config=Configure.Vectorizer.none(),  # Proporcionaremos nuestros propios vectores
    # O: Configure.Vectorizer.text2vec_openai() para vectorización automática
    properties=[
        Property(name="title", data_type=DataType.TEXT),
        Property(name="content", data_type=DataType.TEXT),
        Property(name="author", data_type=DataType.TEXT),
        Property(name="published_date", data_type=DataType.DATE),
        Property(name="tags", data_type=DataType.TEXT_ARRAY),
        Property(name="view_count", data_type=DataType.INT),
    ],
)
print("Colección 'Article' creada")

---

Importación de datos

Importación por lotes con vectores precomputados

import weaviate
import numpy as np
from sentence_transformers import SentenceTransformer

client = weaviate.connect_to_custom(
    http_host="<server-ip>", http_port=8080,
    grpc_host="<server-ip>", grpc_port=50051,
    http_secure=False, grpc_secure=False,
)

# Cargar modelo de incrustación
encoder = SentenceTransformer("all-MiniLM-L6-v2")

# Artículos de ejemplo
articles = [
    {"title": "Introducción a RAG", "content": "RAG combina recuperación con generación..."},
    {"title": "Bases de datos vectoriales explicadas", "content": "Las bases de datos vectoriales almacenan incrustaciones de alta dimensión..."},
    {"title": "Mejores prácticas de Weaviate", "content": "Para despliegues de Weaviate en producción, considere..."},
    {"title": "Computación en nube con GPU", "content": "Clore.ai proporciona acceso descentralizado a GPU..."},
]

# Importación por lotes con vectores
collection = client.collections.get("Article")

with collection.batch.dynamic() as batch:
    for article in articles:
        # Calcular vector
        vector = encoder.encode(article["content"]).tolist()

        batch.add_object(
            properties={
                "title": article["title"],
                "content": article["content"],
            },
            vector=vector,
        )

print(f"Importados {len(articles)} artículos")

Vectorizar automáticamente con OpenAI (en la importación)

# Cuando la colección usa el vectorizador text2vec-openai,
# simplemente inserte datos — no se necesita vector
collection = client.collections.get("ArticleOpenAI")

with collection.batch.dynamic() as batch:
    for article in articles:
        batch.add_object(
            properties={
                "title": article["title"],
                "content": article["content"],
            }
            # Sin vector = Weaviate vectoriza automáticamente vía OpenAI
        )

---

Consultas

Búsqueda semántica (vectorial)

# Encontrar artículos semánticamente similares a una consulta
results = collection.query.near_text(
    query="how to store embeddings efficiently",
    limit=5,
    return_properties=["title", "content"],
    return_metadata=wvc.query.MetadataQuery(distance=True),
)

for obj in results.objects:
    print(f"Título: {obj.properties['title']}")
    print(f"Distancia: {obj.metadata.distance:.4f}")
    print()

Búsqueda híbrida (Vector + BM25)

# Combinar búsqueda semántica y por palabras clave
results = collection.query.hybrid(
    query="RAG retrieval augmented generation",
    alpha=0.5,  # 0.0 = BM25 puro, 1.0 = vector puro, 0.5 = equilibrado
    limit=5,
    return_properties=["title", "content"],
    return_metadata=wvc.query.MetadataQuery(score=True),
)

for obj in results.objects:
    print(f"Título: {obj.properties['title']}")
    print(f"Puntuación híbrida: {obj.metadata.score:.4f}")

Búsqueda por palabra clave (BM25)

results = collection.query.bm25(
    query="vector database indexing",
    limit=5,
    return_properties=["title"],
)

Búsqueda filtrada

from weaviate.classes.query import Filter

# Combinar búsqueda vectorial con filtro de metadatos
results = collection.query.near_text(
    query="machine learning training",
    limit=10,
    filters=Filter.by_property("view_count").greater_than(1000),
    return_properties=["title", "view_count"],
)

Consulta GraphQL

import requests

query = """
{
    Get {
        Article(
            nearText: {concepts: ["artificial intelligence"]}
            limit: 5
        ) {
            title
            content
            _additional {
                distance
                id
            }
        }
    }
}
"""

response = requests.post(
    "http://<server-ip>:8080/v1/graphql",
    json={"query": query},
)
data = response.json()
for article in data["data"]["Get"]["Article"]:
    print(article["title"])

---

Búsqueda generativa (RAG)

from weaviate.classes.generate import GenerateOptions

# Configurar colección con el módulo generativo (OpenAI)
# Requiere ENABLE_MODULES=generative-openai

results = collection.generate.near_text(
    query="how to build a RAG system",
    limit=3,
    grouped_task="Resume estos artículos y explica los pasos clave para construir un sistema RAG.",
    grouped_properties=["title", "content"],
)

print("Respuesta RAG:")
print(results.generated)
print("\nArtículos fuente:")
for obj in results.objects:
    print(f"  - {obj.properties['title']}")

---

Multitenencia

from weaviate.classes.config import Configure

# Crear colección multitenant
client.collections.create(
    name="UserDocuments",
    multi_tenancy_config=Configure.multi_tenancy(enabled=True),
    properties=[
        Property(name="content", data_type=DataType.TEXT),
        Property(name="filename", data_type=DataType.TEXT),
    ],
)

# Crear inquilinos
collection = client.collections.get("UserDocuments")
collection.tenants.create([
    wvc.config.Tenant(name="user_alice"),
    wvc.config.Tenant(name="user_bob"),
])

# Insertar datos para un inquilino específico
tenant_collection = collection.with_tenant("user_alice")
tenant_collection.data.insert({"content": "Documento privado de Alice", "filename": "doc1.pdf"})

# Consultar dentro del inquilino
results = collection.with_tenant("user_alice").query.near_text(
    query="private document",
    limit=5,
)

---

Ejemplos de API REST

# Crear clase de esquema
curl -X POST http://<server-ip>:8080/v1/schema \
    -H "Content-Type: application/json" \
    -d '{
        "class": "Product",
        "vectorizer": "none",
        "properties": [
            {"name": "name", "dataType": ["text"]},
            {"name": "description", "dataType": ["text"]},
            {"name": "price", "dataType": ["number"]}
        ]
    }'

# Añadir objeto con vector
curl -X POST http://<server-ip>:8080/v1/objects \
    -H "Content-Type: application/json" \
    -d '{
        "class": "Product",
        "properties": {
            "name": "Acceso a GPU en la nube",
            "description": "Mercado descentralizado de GPU",
            "price": 0.5
        },
        "vector": [0.1, 0.2, 0.3, ...]
    }'

# Búsqueda vectorial
curl http://<server-ip>:8080/v1/objects?class=Product&limit=5

# Verificación de salud
curl http://<server-ip>:8080/v1/.well-known/ready

---

Solución de problemas

Weaviate no arranca — Compruebe el espacio en disco (df -h). Weaviate necesita espacio escribible en la ruta de datos. También verifique que el puerto 8080 esté abierto en la configuración de Clore.ai.

Importación lenta — Habilite la importación por lotes (collection.batch.dynamic() o fixed_size()). Evite importaciones de un solo objeto para conjuntos de datos grandes. Un tamaño de lote de 100–500 es óptimo.

Alto uso de memoria — Weaviate mantiene el índice vectorial en RAM para búsquedas rápidas. Para 1M de vectores de 768 dimensiones: ~6 GB de RAM. Planifique en consecuencia al elegir el tamaño de la instancia en Clore.ai.

No se puede conectar mediante el cliente Python — Asegúrese de que tanto el puerto 8080 (HTTP) como el puerto 50051 (gRPC) estén abiertos. El cliente Python v4 usa gRPC por defecto.

Problema	Solución
Conexión rechazada	Espere el arranque (~30 s), compruebe docker ps, verifique puertos
El esquema ya existe	Eliminar la colección primero: client.collections.delete("Name")
Sin memoria	Aumente la RAM o reduzca las dimensiones de los vectores
Búsqueda vectorial lenta	Añada índice HNSW o compruebe el tamaño del conjunto de datos frente a la RAM disponible

---

Consejos de rendimiento

1. Use importaciones por lotes — 10x–50x más rápido que inserciones individuales

2. Elija el modelo de incrustación adecuado — all-MiniLM-L6-v2 (384 dims) es rápido; text-embedding-3-large (3072 dims) es la mejor calidad pero usa 8x más RAM

3. Alfa de búsqueda híbrida — ajuste alpha para su caso de uso: 0.25 para consultas centradas en palabras clave, 0.75 para consultas semánticas

4. Parámetros HNSW — ef y efConstruction controla la compensación entre recall y velocidad

5. Aislamiento de inquilinos — use multitenancy para aplicaciones SaaS; escala mucho mejor que colecciones separadas por usuario

---

Herramientas relacionadas

• Qdrant — base de datos vectorial basada en Rust con filtros de payload

• ChromaDB — base de datos de incrustaciones ligera

• Milvus — base de datos vectorial de alta escala

---

Weaviate en Clore.ai le ofrece una base de datos vectorial de nivel de producción con vectorización acelerada por GPU — ideal para construir sistemas RAG escalables y aplicaciones de búsqueda semántica.

---

Recomendaciones de GPU en Clore.ai

Caso de uso	GPU recomendada	Coste estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	~$0.12/gpu/hr
Búsqueda vectorial en producción	RTX 3090 (24GB)	~$0.12/gpu/hr
Embeddings de alto rendimiento	RTX 4090 (24GB)	~$0.70/gpu/hr

💡 Todos los ejemplos en esta guía pueden desplegarse en Clore.ai servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.