Weaviate

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

अवलोकन

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

गुण	मान
श्रेणी	वेक्टर डेटाबेस / RAG अवसंरचना
डेवलपर	Weaviate B.V.
लाइसेंस	BSD 3-Clause
GitHub	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

Weaviate स्वयं CPU पर चलता है। जब आपको लोकल एम्बेडिंग मॉडल इन्फरेंस (उदा., text2vec-transformers के साथ लोकल मॉडल) की आवश्यकता हो, तब Clore.ai पर GPU इंस्टेंस का उपयोग करें ताकि इम्पोर्ट के समय तेज़ वेक्टराइज़ेशन हो सके।

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

1. पर जाएँ clore.ai → मार्केटप्लेस

2. शुद्ध वेक्टर सर्च के लिए: CPU इंस्टेंस जिनमें ≥ 16 GB RAM

3. GPU-त्वरित एम्बेडिंग्स के लिए: RTX 3090 या 4090

4. पोर्ट खोलें: 22 और 8080

5. सुनिश्चित करें ≥ 50 GB डिस्क वेक्टर स्टोरेज के लिए

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

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

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 वेक्टराइज़र के साथ:

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-त्वरित) के साथ:

# 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]

शुरू करें:

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

---

API तक पहुंचना

HTTP/REST API

http://<server-ip>:8080

GraphQL एंडपॉइंट

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

स्वास्थ्य जाँच

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

SSH के माध्यम से

ssh root@<server-ip> -p 22

---

Python क्लाइंट

इंस्टॉलेशन

pip install weaviate-client

कनेक्ट करें

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

---

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

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

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' बनाया गया")

---

डेटा आयात करना

पहले से गणना किए गए वेक्टरों के साथ बैच इम्पोर्ट

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 के साथ ऑटो-वेक्टराइज़ करें (इम्पोर्ट के समय)

# जब 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 के माध्यम से ऑटो-वेक्टराइज़ करता है
        )

---

क्वेरी करना

सिमेंटिक (वेक्टर) सर्च

# किसी क्वेरी से सिमेंटिक रूप से मिलते-जुलते लेख खोजें
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)

# सिमेंटिक और कीवर्ड सर्च को मिलाएं
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)

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

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

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 क्वेरी

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)

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']}")

---

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

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 उदाहरण

# स्कीमा क्लास बनाएं
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

---

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

Weaviate शुरू नहीं हो रहा — डिस्क स्पेस जाँचें (df -h). Weaviate को डेटा पथ पर लिखने योग्य स्थान चाहिए। साथ ही Clore.ai सेटिंग्स में पोर्ट 8080 खुला है, यह सत्यापित करें।

धीमा इम्पोर्ट — बैच इम्पोर्ट सक्षम करें (collection.batch.dynamic() या fixed_size()). बड़े डेटासेट के लिए एक-एक ऑब्जेक्ट इम्पोर्ट से बचें। बैच साइज़ 100–500 सर्वोत्तम है।

उच्च मेमोरी उपयोग — Weaviate तेज़ सर्च के लिए वेक्टर इंडेक्स RAM में रखता है। 1M 768-डिमेंशन वेक्टरों के लिए: लगभग 6 GB RAM। Clore.ai इंस्टेंस साइज़ चुनते समय इसी अनुसार योजना बनाएं।

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

समस्या	ठीक करें
कनेक्शन अस्वीकृत	स्टार्टअप के लिए प्रतीक्षा करें (~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 — payload फ़िल्टर्स के साथ Rust-आधारित वेक्टर डेटाबेस

• ChromaDB — हल्का एम्बेडिंग्स डेटाबेस

• Milvus — उच्च-स्तरीय वेक्टर डेटाबेस

---

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 GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access.