> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/rag-y-bases-de-datos-vectoriales/weaviate.md).

# 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 incorporada de modelos de ML.
{% endhint %}

## Descripción general

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, video, audio), búsqueda híbrida integrada que combina BM25 y similitud vectorial, y despliegues multiinquilino. Weaviate está listo para producción, es nativo de la nube y está diseñado para escalar desde prototipos hasta miles de millones de vectores.

| Propiedad            | Valor                                                     |
| -------------------- | --------------------------------------------------------- |
| **Categoría**        | Infraestructura de base de datos vectorial / RAG          |
| **Desarrollador**    | Weaviate B.V.                                             |
| **Licencia**         | BSD de 3 cláusulas                                        |
| **GitHub**           | [weaviate/weaviate](https://github.com/weaviate/weaviate) |
| **Estrellas**        | 12K+                                                      |
| **Imagen de Docker** | `cr.weaviate.io/semitechnologies/weaviate`                |
| **Puertos**          | 22 (SSH), 8080 (API HTTP / GraphQL)                       |

***

## Características clave

* **Búsqueda híbrida vectorial + por palabras clave** — combinar BM25 de texto completo con similitud vectorial en una sola consulta
* **Vectorizadores integrados** — vectorizar automáticamente los datos al importarlos con OpenAI, Cohere, HuggingFace o modelos locales
* **Multimodal** — almacenar y buscar texto, imágenes, video 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** — aislar datos por inquilino con infraestructura compartida
* **Indexación HNSW** — búsqueda rápida aproximada de vecinos más cercanos
* **Búsqueda filtrada** — combinar búsqueda vectorial con filtros tradicionales de metadatos
* **Búsqueda generativa** — RAG integrado con integración de LLM
* **Escalado horizontal** — fragmentar y replicar en múltiples nodos
* **Sistema de módulos** — conectar vectorizadores, lectores y generadores

***

## Configuración de Clore.ai

### Paso 1 — Elegir hardware

| Caso de uso                           | Recomendado      | RAM    | Almacenamiento |
| ------------------------------------- | ---------------- | ------ | -------------- |
| Desarrollo / prototipado              | Instancia de CPU | 8 GB   | 20 GB          |
| Producción pequeña (< 1M de vectores) | Instancia de 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 en sí se ejecuta en CPU. Usa instancias GPU en Clore.ai cuando necesites **modelo de incrustación local** inferencias (p. ej., `text2vec-transformers` con un modelo local) para una vectorización rápida al importar los datos.
{% 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. Abrir puertos: **22** y **8080**
5. Asegúrate de **≥ 50 GB de disco** para almacenamiento vectorial

### 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 de 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 local de HuggingFace (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
```

***

## Accediendo a la API

### API HTTP/REST

```
http://<server-ip>:8080
```

### Punto final de GraphQL

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

### Comprobación de estado

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

### Vía SSH

```bash
ssh root@<server-ip> -p 22
```

***

## Cliente Python

### Instalación

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

### Conectar

```python
import weaviate
import weaviate.classes as wvc

# Conéctate a tu instancia de 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 (se llamaba "class" en la v3)
client.collections.create(
    name="Article",
    vectorizer_config=Configure.Vectorizer.none(),  # Usaremos 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": "Explicación de las bases de datos vectoriales", "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, considera..."},
    {"title": "Computación en la 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 (al importar)

```python
# Cuando la colección usa el vectorizador text2vec-openai,
# simplemente inserta 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 mediante OpenAI
        )
```

***

## Consultando

### Búsqueda semántica (vectorial)

```python
# Encontrar artículos semánticamente similares a una consulta
results = collection.query.near_text(
    query="cómo almacenar embeddings de manera eficiente",
    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 recuperación aumentada por generación",
    alpha=0.5,  # 0.0 = solo BM25, 1.0 = solo vector, 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 palabras clave (BM25)

```python
results = collection.query.bm25(
    query="indexación de bases de datos vectoriales",
    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="entrenamiento de aprendizaje automático",
    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: ["inteligencia artificial"]}
            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 módulo generativo (OpenAI)
# Requiere ENABLE_MODULES=generative-openai

results = collection.generate.near_text(
    query="cómo construir un sistema RAG",
    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 multiinquilino
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="documento privado",
    limit=5,
)
```

***

## Ejemplos de la 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 la nube con GPU",
            "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

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

***

## Solución de problemas

{% hint style="warning" %}
**Weaviate no arranca** — Comprueba el espacio en disco (`df -h`). Weaviate necesita espacio escribible en la ruta de datos. Además, verifica que el puerto 8080 esté abierto en la configuración de Clore.ai.
{% endhint %}

{% hint style="warning" %}
**Importación lenta** — Habilita la importación por lotes (`collection.batch.dynamic()` o `fixed_size()`). Evita las 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 una búsqueda rápida. Para 1M vectores de 768 dimensiones: \~6 GB de RAM. Planifica en consecuencia al elegir el tamaño de la instancia de Clore.ai.
{% endhint %}

{% hint style="info" %}
**No se puede conectar mediante el cliente Python** — Asegúrate 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`     | Espera el inicio (\~30 s), comprueba `docker ps`, verifica los puertos                      |
| `El esquema ya existe`   | Elimina primero la colección: `client.collections.delete("Name")`                           |
| `Sin memoria`            | Aumenta la RAM o reduce las dimensiones vectoriales                                         |
| Búsqueda vectorial lenta | Añade el índice HNSW o comprueba el tamaño del conjunto de datos frente a la RAM disponible |

***

## Consejos de rendimiento

1. **Usa importaciones por lotes** — 10x–50x más rápido que las inserciones individuales
2. **Elige el modelo de incrustación adecuado** — `all-MiniLM-L6-v2` (384 dimensiones) es rápido; `text-embedding-3-large` (3072 dimensiones) es de mejor calidad, pero usa 8x más RAM
3. **Alpha de búsqueda híbrida** — ajusta `alpha` para tu caso de uso: 0.25 para consultas con mucho peso de palabras clave, 0.75 para consultas semánticas
4. **Parámetros HNSW** — `ef` y `efConstruction` controlan el equilibrio entre recuperación y velocidad
5. **Aislamiento de inquilinos** — usa multitenencia 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 carga útil
* [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 a gran escala

***

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

***

## Recomendaciones de GPU para Clore.ai

| Caso de uso                      | GPU recomendada | Costo estimado en Clore.ai |
| -------------------------------- | --------------- | -------------------------- |
| Desarrollo/Pruebas               | RTX 3090 (24GB) | $0.07–0.21/gpu/hr          |
| Búsqueda vectorial de producción | RTX 3090 (24GB) | $0.07–0.21/gpu/hr          |
| Embeddings de alto rendimiento   | RTX 4090 (24GB) | $0.14–0.42/gpu/hr          |

> 💡 Todos los ejemplos de esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.