# Weaviate

{% hint style="info" %}
**Milvus** एक AI-नेटिव, ओपन-सोर्स वेक्टर डेटाबेस है जो सेमान्टिक सर्च, हाइब्रिड सर्च और RAG (रिट्रीवल-ऑग्मेंटेड जेनरेशन) एप्लिकेशन्स के लिए डिज़ाइन किया गया है। यह वस्तुओं और उनके वेक्टर एम्बेडिंग दोनों को संग्रहीत करता है और बिल्ट-इन ML मॉडल इंटीग्रेशन का समर्थन करता है।
{% endhint %}

## समीक्षा

Weaviate पारंपरिक वेक्टर डेटाबेस से आगे बढ़ता है क्योंकि यह आयात और क्वेरी समय पर स्वचालित वेक्टराइज़ेशन के लिए नेटिव रूप से ML मॉडलों का एकीकरण करता है। यह कई डेटा प्रकारों (टेक्स्ट, इमेज, वीडियो, ऑडियो) का समर्थन करता है, BM25 और वेक्टर सिमिलैरिटी को मिलाकर बिल्ट-इन हाइब्रिड सर्च देता है, और मल्टी-टेनेंट परिनियोजन का समर्थन करता है। Weaviate प्रोडक्शन-रेडी, क्लाउड-नेटिव है और प्रोटोटाइप से लेकर अरबों वेक्टर तक स्केल करने के लिए डिज़ाइन किया गया है।

| संपत्ति                       | मान                                                       |
| ----------------------------- | --------------------------------------------------------- |
| **📚 मार्गदर्शिका श्रेणियाँ** | वेक्टर डेटाबेस / RAG इन्फ्रास्ट्रक्चर                     |
| **डेवलपर**                    | Weaviate B.V.                                             |
| **लाइसेंस**                   | BSD 3-धारा                                                |
| **GitHub**                    | [weaviate/weaviate](https://github.com/weaviate/weaviate) |
| **स्टार**                     | 12K+                                                      |
| **डॉकर इमेज**                 | `cr.weaviate.io/semitechnologies/weaviate`                |
| **पोर्ट्स**                   | 22 (SSH), 8080 (HTTP API / GraphQL)                       |

***

## मुख्य विशेषताएँ

* **वेक्टर + कीवर्ड हाइब्रिड सर्च** — एक ही क्वेरी में BM25 फुल-टेक्स्ट को वेक्टर सिमिलैरिटी के साथ मिलाएँ
* **बिल्ट-इन वेक्टराइज़र्स** — OpenAI, Cohere, HuggingFace, या लोकल मॉडलों के साथ इम्पोर्ट के समय ऑटो-वेक्तोराइज़ करें
* **मल्टी-मोडल** — एक ही डेटाबेस में टेक्स्ट, इमेज, वीडियो, ऑडियो स्टोर और सर्च करें
* **GraphQL API** — जटिल सेमान्टिक क्वेरीज़ के लिए अभिव्यक्तिपूर्ण क्वेरी भाषा
* **REST API** — पूर्ण CRUD ऑपरेशन्स और स्कीमा प्रबंधन
* **मल्टी-टेनेन्सी** — साझा इन्फ्रास्ट्रक्चर के साथ प्रति टेनेंट डेटा को अलग-थलग करें
* **HNSW इंडेक्सिंग** — तेज़ अनुमानित नज़दीकी-पड़ोसी खोज
* **फ़िल्टर की गई खोज** — पारंपरिक मेटाडेटा फ़िल्टर के साथ वेक्टर सर्च मिलाएँ
* **जेनेरेटिव सर्च** — LLM इंटीग्रेशन के साथ बिल्ट-इन RAG
* **हॉरिजॉन्टल स्केलिंग** — कई नोड्स में शार्ड और रिप्लिकेट करें
* **मॉड्यूल्स सिस्टम** — वेक्टराइज़र्स, रीडर्स, जेनरेटर्स प्लग-इन करें

***

## Clore.ai सेटअप

### चरण 1 — हार्डवेयर चुनें

| उपयोग केस                    | अनुशंसित     | RAM    | स्टोरेज |
| ---------------------------- | ------------ | ------ | ------- |
| डेवलपमेंट / प्रोटोटाइपिंग    | CPU इंस्टेंस | 8 GB   | 20 GB   |
| छोटी प्रोडक्शन (< 1M वेक्टर) | CPU इंस्टेंस | 16 GB  | 50 GB   |
| बड़ी स्केल (10M+ वेक्टर)     | GPU इंस्टेंस | 32 GB+ | 200 GB+ |
| GPU-त्वरित वेक्टराइज़ेशन     | RTX 4090     | 24 GB  | 100 GB  |

{% hint style="info" %}
Weaviate स्वयं CPU पर चलता है। जब आपको आवश्यकता हो तो Clore.ai पर GPU इंस्टेंस का उपयोग करें **लोकल एम्बेडिंग मॉडल** इनफरेंस (उदा., `text2vec-transformers` लोकल मॉडल के साथ) इम्पोर्ट समय पर तेज़ वेक्टराइज़ेशन के लिए।
{% endhint %}

### चरण 2 — Clore.ai पर सर्वर किराए पर लें

1. जाएँ [clore.ai](https://clore.ai) → **मार्केटप्लेस**
2. &#x20;शुद्ध वेक्टर सर्च के लिए: CPU इंस्टेंस के साथ **≥ 16 GB RAM**
3. GPU-त्वरित एम्बेडिंग के लिए: **RTX 3090 या 4090**
4. खुले पोर्ट्स: **22** और **8080**
5. सुनिश्चित करें **≥ 50 GB डिस्क** वेक्टर स्टोरेज के लिए

### चरण 3 — Docker के साथ डिप्लॉय करें

**न्यूनतम परिनियोजन (कोई वेक्टराइज़र नहीं):**

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

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

**लोकल HuggingFace वेक्टराइज़र (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]
```

शुरू करें:

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

***

## API तक पहुँच

### HTTP/REST API

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

### GraphQL एंडपॉइंट

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

### हेल्थ चेक

```bash
curl http://<server-ip>:8080/v1/.well-known/ready
# रिटर्न: {}  (HTTP 200 = स्वस्थ)
```

### SSH के माध्यम से

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

***

## Python क्लाइंट

### इंस्टॉलेशन

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

### कनेक्ट करें

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

# अपने 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
```

***

## स्कीमा और कलेक्शन्स

### एक कलेक्शन बनाएं

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

# एक कलेक्शन बनाएं (v3 में इसे "class" कहा जाता था)
client.collections.create(
    name="Article",
    vectorizer_config=Configure.Vectorizer.none(),  # हम अपने स्वयं के वेक्टर प्रदान करेंगे
    # या: Configure.Vectorizer.text2vec_openai() ऑटो-वेक्तोराइज़ेशन के लिए
    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("कलेक्शन 'Article' बनाया गया")
```

***

## डेटा इम्पोर्ट करना

### प्री-कम्प्यूटेड वेक्टर के साथ बैच इम्पोर्ट

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

# एम्बेडिंग मॉडल लोड करें
encoder = SentenceTransformer("all-MiniLM-L6-v2")

# नमूना लेख
articles = [
    {"title": "RAG का परिचय", "content": "RAG रिट्रीवल को जेनरेशन के साथ जोड़ता है..."},
    {"title": "वेक्टर डेटाबेस व्याख्या", "content": "वेक्टर डेटाबेस उच्च-आयामी एम्बेडिंग्स संग्रहीत करते हैं..."},
    {"title": "Weaviate सर्वोत्तम प्रथाएँ", "content": "प्रोडक्शन Weaviate परिनियोजन के लिए, विचार करें..."},
    {"title": "GPU क्लाउड कंप्यूटिंग", "content": "Clore.ai विकेंद्रीकृत GPU एक्सेस प्रदान करता है..."},
]

# वेक्टर के साथ बैच इम्पोर्ट
collection = client.collections.get("Article")

with collection.batch.dynamic() as batch:
    for article in articles:
        # वेक्टर गणना करें
        vector = encoder.encode(article["content"]).tolist()

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

print(f"Imported {len(articles)} articles")
```

### OpenAI के साथ ऑटो-वेक्तोराइज़ (इम्पोर्ट पर)

```python
# जब कलेक्शन text2vec-openai वेक्टराइज़र का उपयोग करता है,
# बस डेटा डालें — किसी वेक्टर की आवश्यकता नहीं
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"],
            }
            # कोई वेक्टर नहीं = Weaviate OpenAI के माध्यम से ऑटो-वेक्तोराइज़ करेगा
        )
```

***

## क्वेरी करना

### सेमान्टिक (वेक्टर) सर्च

```python
# किसी क्वेरी के सापेक्ष सेमान्टिक रूप से समान लेख ढूंढें
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"Title: {obj.properties['title']}")
    print(f"Distance: {obj.metadata.distance:.4f}")
    print()
```

### हाइब्रिड सर्च (वेक्टर + BM25)

```python
# सेमान्टिक और कीवर्ड सर्च को मिलाएँ
results = collection.query.hybrid(
    query="RAG retrieval augmented generation",
    alpha=0.5,  # 0.0 = शुद्ध BM25, 1.0 = शुद्ध वेक्टर, 0.5 = संतुलित
    limit=5,
    return_properties=["title", "content"],
    return_metadata=wvc.query.MetadataQuery(score=True),
)

for obj in results.objects:
    print(f"Title: {obj.properties['title']}")
    print(f"Hybrid Score: {obj.metadata.score:.4f}")
```

### कीवर्ड सर्च (BM25)

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

### फ़िल्टर की गई सर्च

```python
from weaviate.classes.query import Filter

# मेटाडेटा फ़िल्टर के साथ वेक्टर सर्च मिलाएँ
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"],
)
```

### 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"])
```

***

## जेनेरेटिव सर्च (RAG)

```python
from weaviate.classes.generate import GenerateOptions

# जेनरेटिव मॉड्यूल (OpenAI) के साथ कलेक्शन सेट करें
# Requires ENABLE_MODULES=generative-openai

results = collection.generate.near_text(
    query="how to build a RAG system",
    limit=3,
    grouped_task="इन लेखों का सार दें और RAG सिस्टम बनाने के मुख्य चरण समझाएँ.",
    grouped_properties=["title", "content"],
)

print("RAG उत्तर:")
print(results.generated)
print("\nस्रोत लेख:")
for obj in results.objects:
    print(f"  - {obj.properties['title']}")
```

***

## मल्टी-टेनेन्सी

```python
from weaviate.classes.config import Configure

# मल्टी-टेनेंट कलेक्शन बनाएं
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),
    ],
)

# टेनेंट बनाएं
collection = client.collections.get("UserDocuments")
collection.tenants.create([
    wvc.config.Tenant(name="user_alice"),
    wvc.config.Tenant(name="user_bob"),
])

# विशिष्ट टेनेंट के लिए डेटा डालें
tenant_collection = collection.with_tenant("user_alice")
tenant_collection.data.insert({"content": "Alice's private document", "filename": "doc1.pdf"})

# टेनेंट के भीतर क्वेरी करें
results = collection.with_tenant("user_alice").query.near_text(
    query="private document",
    limit=5,
)
```

***

## REST API उदाहरण

```bash
# स्कीमा क्लास बनाएं
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"]}
        ]
    }'

# वेक्टर के साथ ऑब्जेक्ट जोड़ें
curl -X POST http://<server-ip>:8080/v1/objects \
    -H "Content-Type: application/json" \
    -d '{
        "class": "Product",
        "properties": {
            "name": "GPU Cloud Access",
            "description": "विकेंद्रीकृत GPU मार्केटप्लेस",
            "price": 0.5
        },
        "vector": [0.1, 0.2, 0.3, ...]
    }'

# वेक्टर सर्च
curl http://<server-ip>:8080/v1/objects?class=Product&limit=5

# हेल्थ चेक
curl http://<server-ip>:8080/v1/.well-known/ready
```

***

## समस्या निवारण

{% hint style="warning" %}
**Weaviate शुरू नहीं हो रहा** — डिस्क स्पेस जांचें (`df -h`). Weaviate को डेटा पाथ में लिखने योग्य स्थान चाहिए। साथ ही Clore.ai सेटिंग्स में पोर्ट 8080 खुला है यह सत्यापित करें।
{% endhint %}

{% hint style="warning" %}
**इम्पोर्ट धीमा है** — बैच इम्पोर्ट सक्षम करें (`collection.batch.dynamic()` इमेज जेनरेट करें `fixed_size()`). बड़े डेटासेट के लिए सिंगल-ऑब्जेक्ट इम्पोर्ट से बचें। बैच साइज 100–500 अनुकूल है।
{% endhint %}

{% hint style="info" %}
**उच्च मेमोरी उपयोग** — Weaviate तेज़ सर्च के लिए वेक्टर इंडेक्स RAM में रखता है। 1M 768-डिम वेक्टर्स के लिए: \~6 GB RAM। Clore.ai इंस्टेंस आकार चुनते समय मानचित्रण करें।
{% endhint %}

{% hint style="info" %}
**Python क्लाइंट के माध्यम से कनेक्ट नहीं कर सकते** — सुनिश्चित करें कि पोर्ट 8080 (HTTP) और पोर्ट 50051 (gRPC) दोनों खुले हैं। v4 Python क्लाइंट डिफ़ॉल्ट रूप से gRPC का उपयोग करता है।
{% endhint %}

| मुद्दा                      | समाधान                                                                            |
| --------------------------- | --------------------------------------------------------------------------------- |
| `कनेक्शन अस्वीकार किया गया` | स्टार्टअप की प्रतीक्षा करें (\~30 सेकंड), जांचें `docker ps`, पोर्ट सत्यापित करें |
| `स्कीमा पहले से मौजूद है`   | पहले कलेक्शन हटाएँ: `client.collections.delete("Name")`                           |
| `मेमोरी खत्म`               | RAM बढ़ाएँ या वेक्टर आयाम घटाएँ                                                   |
| वेक्टर सर्च धीमा है         | HNSW इंडेक्स जोड़ें या उपलब्ध RAM के सापेक्ष डेटासेट आकार जांचें                  |

***

## प्रदर्शन सुझाव

1. **बैच इम्पोर्ट्स का उपयोग करें** — सिंगल इन्सर्ट से 10x–50x तेज़
2. **सही एम्बेडिंग मॉडल चुनें** आणविक गतिशीलता `all-MiniLM-L6-v2` (384 डिम) तेज़ है; `text-embedding-3-large` (3072 डिम) सर्वश्रेष्ठ गुणवत्ता है लेकिन 8x अधिक RAM उपयोग करता है
3. **हाइब्रिड सर्च अल्फा** — अपने उपयोग के मामले के लिए ट्यून करें `alpha` कीवर्ड-भारी क्वेरीज़ के लिए 0.25, सेमान्टिक क्वेरीज़ के लिए 0.75
4. **HNSW पैरामीटर** आणविक गतिशीलता `ef` और `efConstruction` रीकॉल बनाम गति के ट्रेडऑफ को नियंत्रित करें
5. **टेनेंट अलगाव** — SaaS ऐप्स के लिए मल्टी-टेनेन्सी का उपयोग करें; यह प्रति-उपयोगकर्ता अलग कलेक्शन्स की तुलना में कहीं बेहतर स्केल करता है

***

## संबंधित उपकरण

* [ChromaDB](https://docs.clore.ai/guides/guides_v2-hi/rag/qdrant) — पेलोड फ़िल्टर्स के साथ Rust-आधारित वेक्टर डेटाबेस
* [RAGFlow](https://docs.clore.ai/guides/guides_v2-hi/rag/chromadb) — हल्का एम्बेडिंग्स डेटाबेस
* [Qdrant](https://docs.clore.ai/guides/guides_v2-hi/rag/milvus) — उच्च-स्केल वेक्टर डेटाबेस

***

*Clore.ai पर Weaviate आपको GPU-त्वरित वेक्टराइज़ेशन के साथ प्रोडक्शन-ग्रेड वेक्टर डेटाबेस देता है — स्केलेबल RAG सिस्टम और सेमान्टिक सर्च एप्लिकेशन बनाने के लिए आदर्श।*

***

## Clore.ai GPU सिफारिशें

| उपयोग केस             | सिफारिश की गई GPU | Clore.ai पर अनुमानित लागत |
| --------------------- | ----------------- | ------------------------- |
| डेवलपमेंट/टेस्टिंग    | RTX 3090 (24GB)   | \~$0.12/gpu/hr            |
| प्रोडक्शन वेक्टर सर्च | RTX 3090 (24GB)   | \~$0.12/gpu/hr            |
| हाई-थ्रूपुट एम्बेडिंग | RTX 4090 (24GB)   | \~$0.70/gpu/hr            |

> 💡 इस गाइड के सभी उदाहरण तैनात किए जा सकते हैं [Clore.ai](https://clore.ai/marketplace) GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।