> 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-hi/rag/weaviate.md).

# Weaviate

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

## अवलोकन

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

| गुण             | मान                                                       |
| --------------- | --------------------------------------------------------- |
| **श्रेणी**      | वेक्टर डेटाबेस / RAG अवसंरचना                             |
| **डेवलपर**      | Weaviate B.V.                                             |
| **लाइसेंस**     | BSD 3-Clause                                              |
| **GitHub**      | [weaviate/weaviate](https://github.com/weaviate/weaviate) |
| **स्टार्स**     | 12K+                                                      |
| **Docker इमेज** | `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 पर चलता है। जब आपको **लोकल एम्बेडिंग मॉडल** इन्फरेंस (उदा., `text2vec-transformers` के साथ लोकल मॉडल) की आवश्यकता हो, तब Clore.ai पर GPU इंस्टेंस का उपयोग करें ताकि इम्पोर्ट के समय तेज़ वेक्टराइज़ेशन हो सके।
{% endhint %}

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

1. पर जाएँ [clore.ai](https://clore.ai) → **मार्केटप्लेस**
2. शुद्ध वेक्टर सर्च के लिए: 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"{len(articles)} लेख आयात किए गए")
```

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

```python
# जब collection 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="एम्बेडिंग्स को कुशलतापूर्वक कैसे स्टोर करें",
    limit=5,
    return_properties=["title", "content"],
    return_metadata=wvc.query.MetadataQuery(distance=True),
)

for obj in results.objects:
    print(f"शीर्षक: {obj.properties['title']}")
    print(f"दूरी: {obj.metadata.distance:.4f}")
    print()
```

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

```python
# सिमेंटिक और कीवर्ड सर्च को मिलाएं
results = collection.query.hybrid(
    query="RAG रिट्रीवल ऑगमेंटेड जेनरेशन",
    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"शीर्षक: {obj.properties['title']}")
    print(f"हाइब्रिड स्कोर: {obj.metadata.score:.4f}")
```

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

```python
results = collection.query.bm25(
    query="वेक्टर डेटाबेस इंडेक्सिंग",
    limit=5,
    return_properties=["title"],
)
```

### फ़िल्टर्ड सर्च

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

# वेक्टर सर्च को मेटाडेटा फ़िल्टर के साथ मिलाएं
results = collection.query.near_text(
    query="मशीन लर्निंग प्रशिक्षण",
    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: ["कृत्रिम बुद्धिमत्ता"]}
            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) के साथ कलेक्शन सेट करें
# ENABLE_MODULES=generative-openai आवश्यक है

results = collection.generate.near_text(
    query="RAG सिस्टम कैसे बनाएं",
    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": "ऐलिस का निजी दस्तावेज़", "filename": "doc1.pdf"})

# टेनेंट के भीतर क्वेरी करें
results = collection.with_tenant("user_alice").query.near_text(
    query="निजी दस्तावेज़",
    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 क्लाउड एक्सेस",
            "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 ऐप्स के लिए मल्टी-टेनेंसी का उपयोग करें; यह प्रति उपयोगकर्ता अलग-अलग कलेक्शन्स की तुलना में बहुत बेहतर स्केल करता है

***

## संबंधित टूल्स

* [Qdrant](/guides/guides_v2-hi/rag/qdrant.md) — payload फ़िल्टर्स के साथ Rust-आधारित वेक्टर डेटाबेस
* [ChromaDB](/guides/guides_v2-hi/rag/chromadb.md) — हल्का एम्बेडिंग्स डेटाबेस
* [Milvus](/guides/guides_v2-hi/rag/milvus.md) — उच्च-स्तरीय वेक्टर डेटाबेस

***

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

***

## Clore.ai GPU अनुशंसाएँ

| उपयोग-प्रकरण           | अनुशंसित GPU    | Clore.ai पर अनुमानित लागत |
| ---------------------- | --------------- | ------------------------- |
| विकास/परीक्षण          | RTX 3090 (24GB) | $0.07–0.21/gpu/hr         |
| प्रोडक्शन वेक्टर सर्च  | RTX 3090 (24GB) | $0.07–0.21/gpu/hr         |
| उच्च-थ्रूपुट एम्बेडिंग | RTX 4090 (24GB) | $0.14–0.42/gpu/hr         |

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


---

# 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-hi/rag/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.