# Weaviate

{% hint style="info" %}
**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.
{% endhint %}

## 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](https://github.com/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         |

{% hint style="info" %}
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.
{% endhint %}

### Paso 2 — Alquila un servidor en Clore.ai

1. Ve a [clore.ai](https://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):**

```bash
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:**

```bash
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):**

```yaml
# 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:

```bash
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

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

### Vía SSH

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

***

## Cliente Python

### Instalación

```bash
pip install weaviate-client
```

### Conectar

```python
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

```python
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

```python
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)

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

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

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

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

### Búsqueda filtrada

```python
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

```python
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)

```python
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

```python
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

```bash
# 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

{% hint style="warning" %}
**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.
{% endhint %}

{% hint style="warning" %}
**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.
{% endhint %}

{% hint style="info" %}
**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.
{% endhint %}

{% hint style="info" %}
**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.
{% endhint %}

| 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](/guides/guides_v2-es/rag-y-bases-de-datos-vectoriales/qdrant.md) — base de datos vectorial basada en Rust con filtros de payload
* [ChromaDB](/guides/guides_v2-es/rag-y-bases-de-datos-vectoriales/chromadb.md) — base de datos de incrustaciones ligera
* [Milvus](/guides/guides_v2-es/rag-y-bases-de-datos-vectoriales/milvus.md) — 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](https://clore.ai/marketplace) servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/rag-y-bases-de-datos-vectoriales/weaviate.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.