---
layout: default
title: "निष्कर्षण प्रवाह (निकालने की प्रक्रियाएं)"
parent: "Hindi (Beta)"
---

# निष्कर्षण प्रवाह (निकालने की प्रक्रियाएं)

> **Beta Translation:** This document was translated via Machine Learning and as such may not be 100% accurate. All non-English languages are currently classified as Beta.

यह दस्तावेज़ बताता है कि डेटा ट्रस्टग्राफ निष्कर्षण पाइपलाइन के माध्यम से कैसे प्रवाहित होता है, दस्तावेज़ जमा करने से लेकर ज्ञान भंडारों में भंडारण तक।

## अवलोकन

```
┌──────────┐     ┌─────────────┐     ┌─────────┐     ┌────────────────────┐
│ Librarian│────▶│ PDF Decoder │────▶│ Chunker │────▶│ Knowledge          │
│          │     │ (PDF only)  │     │         │     │ Extraction         │
│          │────────────────────────▶│         │     │                    │
└──────────┘     └─────────────┘     └─────────┘     └────────────────────┘
                                          │                    │
                                          │                    ├──▶ Triples
                                          │                    ├──▶ Entity Contexts
                                          │                    └──▶ Rows
                                          │
                                          └──▶ Document Embeddings
```

## सामग्री भंडारण

### ब्लॉब भंडारण (S3/Minio)

दस्तावेज़ सामग्री S3-संगत ब्लॉब भंडारण में संग्रहीत की जाती है:
पथ प्रारूप: `doc/{object_id}` जहाँ object_id एक UUID है
सभी दस्तावेज़ प्रकार यहां संग्रहीत किए जाते हैं: स्रोत दस्तावेज़, पृष्ठ, खंड

### मेटाडेटा भंडारण (कैसेंड्रा)

कैसेंड्रा में संग्रहीत दस्तावेज़ मेटाडेटा में शामिल हैं:
दस्तावेज़ आईडी, शीर्षक, प्रकार (MIME प्रकार)
ब्लॉब भंडारण के लिए `object_id` संदर्भ
चाइल्ड दस्तावेज़ों (पृष्ठों, खंडों) के लिए `parent_id`
`document_type`: "स्रोत", "पृष्ठ", "खंड", "उत्तर"

### इनलाइन बनाम स्ट्रीमिंग थ्रेशोल्ड

सामग्री प्रेषण एक आकार-आधारित रणनीति का उपयोग करता है:
**< 2MB**: सामग्री संदेश में इनलाइन शामिल है (base64-एन्कोडेड)
**≥ 2MB**: केवल `document_id` भेजा जाता है; प्रोसेसर लाइब्रेरियन API के माध्यम से प्राप्त करता है

## चरण 1: दस्तावेज़ सबमिशन (लाइब्रेरियन)

### प्रवेश बिंदु

दस्तावेज़ लाइब्रेरियन के `add-document` ऑपरेशन के माध्यम से सिस्टम में प्रवेश करते हैं:
1. सामग्री को ब्लॉब भंडारण में अपलोड किया जाता है
2. कैसेंड्रा में मेटाडेटा रिकॉर्ड बनाया जाता है
3. दस्तावेज़ आईडी वापस करता है

### निष्कर्षण को ट्रिगर करना

`add-processing` ऑपरेशन निष्कर्षण को ट्रिगर करता है:
`document_id`, `flow` (पाइपलाइन आईडी), `collection` (लक्ष्य स्टोर) निर्दिष्ट करता है
लाइब्रेरियन का `load_document()` सामग्री प्राप्त करता है और फ्लो इनपुट कतार पर प्रकाशित करता है

### स्कीमा: दस्तावेज़

```
Document
├── metadata: Metadata
│   ├── id: str              # Document identifier
│   ├── user: str            # Tenant/user ID
│   ├── collection: str      # Target collection
│   └── metadata: list[Triple]  # (largely unused, historical)
├── data: bytes              # PDF content (base64, if inline)
└── document_id: str         # Librarian reference (if streaming)
```

**राउटिंग (Routing)**: `kind` फ़ील्ड के आधार पर:
`application/pdf` → `document-load` क्यू → पीडीएफ डिकोडर
`text/plain` → `text-load` क्यू → चंकर

## चरण 2: पीडीएफ डिकोडर

पीडीएफ दस्तावेजों को टेक्स्ट पृष्ठों में परिवर्तित करता है।

### प्रक्रिया

1. सामग्री प्राप्त करें (इनलाइन `data` या लाइब्रेरियन से `document_id` के माध्यम से)
2. PyPDF का उपयोग करके पृष्ठों को निकालें
3. प्रत्येक पृष्ठ के लिए:
   लाइब्रेरियन में चाइल्ड दस्तावेज़ के रूप में सहेजें (`{doc_id}/p{page_num}`)
   प्रामाणिकता ट्रिपल उत्सर्जित करें (पृष्ठ दस्तावेज़ से प्राप्त है)
   चंकर को अग्रेषित करें

### स्कीमा: TextDocument

```
TextDocument
├── metadata: Metadata
│   ├── id: str              # Page URI (e.g., https://trustgraph.ai/doc/xxx/p1)
│   ├── user: str
│   ├── collection: str
│   └── metadata: list[Triple]
├── text: bytes              # Page text content (if inline)
└── document_id: str         # Librarian reference (e.g., "doc123/p1")
```

## चरण 3: चंकर (Chunker)

यह टेक्स्ट को कॉन्फ़िगर किए गए आकार में टुकड़ों में विभाजित करता है।

### पैरामीटर (फ्लो-कॉन्फ़िगर करने योग्य)

`chunk_size`: अक्षरों में लक्षित टुकड़ा आकार (डिफ़ॉल्ट: 2000)
`chunk_overlap`: टुकड़ों के बीच ओवरलैप (डिफ़ॉल्ट: 100)

### प्रक्रिया

1. टेक्स्ट सामग्री प्राप्त करें (इनलाइन या लाइब्रेरियन के माध्यम से)
2. रिकर्सिव कैरेक्टर स्प्लिटर का उपयोग करके विभाजित करें
3. प्रत्येक टुकड़े के लिए:
   लाइब्रेरियन में चाइल्ड दस्तावेज़ के रूप में सहेजें (`{parent_id}/c{index}`)
   प्रामाणिकता ट्रिपल उत्सर्जित करें (टुकड़ा पृष्ठ/दस्तावेज़ से प्राप्त हुआ है)
   निष्कर्षण प्रोसेसर को अग्रेषित करें

### स्कीमा: टुकड़ा (Chunk)

```
Chunk
├── metadata: Metadata
│   ├── id: str              # Chunk URI
│   ├── user: str
│   ├── collection: str
│   └── metadata: list[Triple]
├── chunk: bytes             # Chunk text content
└── document_id: str         # Librarian chunk ID (e.g., "doc123/p1/c3")
```

### दस्तावेज़ आईडी पदानुक्रम

चाइल्ड दस्तावेज़ अपनी उत्पत्ति को आईडी में एन्कोड करते हैं:
स्रोत: `doc123`
पृष्ठ: `doc123/p5`
पृष्ठ से अंश: `doc123/p5/c2`
पाठ से अंश: `doc123/c2`

## चरण 4: ज्ञान निष्कर्षण

कई निष्कर्षण पैटर्न उपलब्ध हैं, जिन्हें प्रवाह कॉन्फ़िगरेशन द्वारा चुना जाता है।

### पैटर्न ए: बेसिक ग्राफआरएजी

दो समानांतर प्रोसेसर:

**kg-extract-definitions**
इनपुट: अंश
आउटपुट: ट्रिपल (इकाई परिभाषाएँ), एंटिटीकॉन्टेक्स्ट
निष्कर्षण: इकाई लेबल, परिभाषाएँ

**kg-extract-relationships**
इनपुट: अंश
आउटपुट: ट्रिपल (संबंध), एंटिटीकॉन्टेक्स्ट
निष्कर्षण: विषय-क्रिया-वस्तु संबंध

### पैटर्न बी: ऑन्टोलॉजी-संचालित (kg-extract-ontology)

इनपुट: अंश
आउटपुट: ट्रिपल, एंटिटीकॉन्टेक्स्ट
निष्कर्षण को निर्देशित करने के लिए कॉन्फ़िगर की गई ऑन्टोलॉजी का उपयोग करता है

### पैटर्न सी: एजेंट-आधारित (kg-extract-agent)

इनपुट: अंश
आउटपुट: ट्रिपल, एंटिटीकॉन्टेक्स्ट
निष्कर्षण के लिए एजेंट फ्रेमवर्क का उपयोग करता है

### पैटर्न डी: पंक्ति निष्कर्षण (kg-extract-rows)

इनपुट: अंश
आउटपुट: पंक्तियाँ (संरचित डेटा, ट्रिपल नहीं)
संरचित रिकॉर्ड निकालने के लिए स्कीमा परिभाषा का उपयोग करता है

### स्कीमा: ट्रिपल

```
Triples
├── metadata: Metadata
│   ├── id: str
│   ├── user: str
│   ├── collection: str
│   └── metadata: list[Triple]  # (set to [] by extractors)
└── triples: list[Triple]
    └── Triple
        ├── s: Term              # Subject
        ├── p: Term              # Predicate
        ├── o: Term              # Object
        └── g: str | None        # Named graph
```

### स्कीमा: एंटिटीकॉन्टेक्स्ट्स

```
EntityContexts
├── metadata: Metadata
└── entities: list[EntityContext]
    └── EntityContext
        ├── entity: Term         # Entity identifier (IRI)
        ├── context: str         # Textual description for embedding
        └── chunk_id: str        # Source chunk ID (provenance)
```

### स्कीमा: पंक्तियाँ

```
Rows
├── metadata: Metadata
├── row_schema: RowSchema
│   ├── name: str
│   ├── description: str
│   └── fields: list[Field]
└── rows: list[dict[str, str]]   # Extracted records
```

## चरण 5: एम्बेडिंग पीढ़ी

### ग्राफ एम्बेडिंग

इकाई संदर्भों को वेक्टर एम्बेडिंग में परिवर्तित करता है।

**प्रक्रिया:**
1. इकाई संदर्भ प्राप्त करें
2. संदर्भ पाठ के साथ एम्बेडिंग सेवा को कॉल करें
3. ग्राफ एम्बेडिंग आउटपुट करें (इकाई → वेक्टर मैपिंग)

**स्कीमा: ग्राफ एम्बेडिंग**

```
GraphEmbeddings
├── metadata: Metadata
└── entities: list[EntityEmbeddings]
    └── EntityEmbeddings
        ├── entity: Term         # Entity identifier
        ├── vector: list[float]  # Embedding vector
        └── chunk_id: str        # Source chunk (provenance)
```

### दस्तावेज़ एम्बेडिंग

यह सीधे टेक्स्ट के टुकड़ों को वेक्टर एम्बेडिंग में परिवर्तित करता है।

**प्रक्रिया:**
1. टेक्स्ट का टुकड़ा प्राप्त करें
2. टेक्स्ट के टुकड़े के साथ एम्बेडिंग सेवा को कॉल करें
3. दस्तावेज़एम्बेडिंग आउटपुट करें

**स्कीमा: दस्तावेज़एम्बेडिंग**

```
DocumentEmbeddings
├── metadata: Metadata
└── chunks: list[ChunkEmbeddings]
    └── ChunkEmbeddings
        ├── chunk_id: str        # Chunk identifier
        └── vector: list[float]  # Embedding vector
```

### पंक्ति एम्बेडिंग (पंक्ति एम्बेडिंग)

पंक्ति अनुक्रमणिका फ़ील्ड को वेक्टर एम्बेडिंग में परिवर्तित करता है।

**प्रक्रिया:**
1. पंक्तियों को प्राप्त करें
2. कॉन्फ़िगर की गई अनुक्रमणिका फ़ील्ड को एम्बेड करें
3. पंक्ति वेक्टर स्टोर पर आउटपुट करें

## चरण 6: भंडारण (चरण 6: भंडारण)

### ट्रिपल स्टोर (ट्रिपल स्टोर)

प्राप्त करता है: ट्रिपल (प्राप्त करता है: ट्रिपल)
भंडारण: कैसेंड्रा (इकाई-केंद्रित तालिकाएँ) (भंडारण: कैसेंड्रा (इकाई-केंद्रित तालिकाएँ))
नामित ग्राफ मूल ज्ञान को उत्पत्ति से अलग करते हैं: (नामित ग्राफ मूल ज्ञान को उत्पत्ति से अलग करते हैं:)
  `""` (डिफ़ॉल्ट): मूल ज्ञान तथ्य (डिफ़ॉल्ट: मूल ज्ञान तथ्य)
  `urn:graph:source`: निष्कर्षण उत्पत्ति (निष्कर्षण उत्पत्ति)
  `urn:graph:retrieval`: क्वेरी-टाइम व्याख्या (क्वेरी-टाइम व्याख्या)

### वेक्टर स्टोर (ग्राफ एम्बेडिंग) (वेक्टर स्टोर (ग्राफ एम्बेडिंग))

प्राप्त करता है: GraphEmbeddings (प्राप्त करता है: GraphEmbeddings)
भंडारण: Qdrant, Milvus, या Pinecone (भंडारण: Qdrant, Milvus, या Pinecone)
अनुक्रमित: इकाई IRI द्वारा (अनुक्रमित: इकाई IRI द्वारा)
मेटाडेटा: उत्पत्ति के लिए chunk_id (मेटाडेटा: उत्पत्ति के लिए chunk_id)

### वेक्टर स्टोर (दस्तावेज़ एम्बेडिंग) (वेक्टर स्टोर (दस्तावेज़ एम्बेडिंग))

प्राप्त करता है: DocumentEmbeddings (प्राप्त करता है: DocumentEmbeddings)
भंडारण: Qdrant, Milvus, या Pinecone (भंडारण: Qdrant, Milvus, या Pinecone)
अनुक्रमित: chunk_id द्वारा (अनुक्रमित: chunk_id द्वारा)

### पंक्ति स्टोर (पंक्ति स्टोर)

प्राप्त करता है: Rows (प्राप्त करता है: Rows)
भंडारण: कैसेंड्रा (भंडारण: कैसेंड्रा)
स्कीमा-संचालित तालिका संरचना (स्कीमा-संचालित तालिका संरचना)

### पंक्ति वेक्टर स्टोर (पंक्ति वेक्टर स्टोर)

प्राप्त होता है: पंक्ति एम्बेडिंग (पंक्ति एम्बेडिंग)
भंडारण: वेक्टर डेटाबेस (वेक्टर डेटाबेस)
अनुक्रमित किया गया: पंक्ति अनुक्रमणिका फ़ील्ड द्वारा (पंक्ति अनुक्रमणिका फ़ील्ड द्वारा)

## मेटाडेटा फ़ील्ड विश्लेषण (मेटाडेटा फ़ील्ड विश्लेषण)

### सक्रिय रूप से उपयोग किए जाने वाले फ़ील्ड (सक्रिय रूप से उपयोग किए जाने वाले फ़ील्ड)

| फ़ील्ड | उपयोग |
|-------|-------|
| `metadata.id` | दस्तावेज़/चंक पहचानकर्ता, लॉगिंग, उत्पत्ति (दस्तावेज़/चंक पहचानकर्ता, लॉगिंग, उत्पत्ति)
| `metadata.user` | मल्टी-टेनेंसी, स्टोरेज रूटिंग (मल्टी-टेनेंसी, स्टोरेज रूटिंग)
| `metadata.collection` | लक्ष्य संग्रह चयन (लक्ष्य संग्रह चयन)
| `document_id` | लाइब्रेरियन संदर्भ, उत्पत्ति लिंकिंग (लाइब्रेरियन संदर्भ, उत्पत्ति लिंकिंग)
| `chunk_id` | पाइपलाइन के माध्यम से उत्पत्ति ट्रैकिंग (पाइपलाइन के माध्यम से उत्पत्ति ट्रैकिंग)

<<<<<<< HEAD
### संभावित रूप से अनावश्यक फ़ील्ड (संभावित रूप से अनावश्यक फ़ील्ड)

| फ़ील्ड | स्थिति |
|-------|--------|
| `metadata.metadata` | सभी एक्सट्रैक्टरों द्वारा `[]` पर सेट; दस्तावेज़-स्तरीय मेटाडेटा अब सबमिशन के समय लाइब्रेरियन द्वारा संभाला जाता है (सभी एक्सट्रैक्टरों द्वारा `[]` पर सेट; दस्तावेज़-स्तरीय मेटाडेटा अब सबमिशन के समय लाइब्रेरियन द्वारा संभाला जाता है)
=======
### हटाए गए फ़ील्ड (हटाए गए फ़ील्ड)

| फ़ील्ड | स्थिति |
|-------|--------|
| `metadata.metadata` | `Metadata` वर्ग से हटा दिया गया। दस्तावेज़-स्तरीय मेटाडेटा ट्रिपल अब सीधे लाइब्रेरियन द्वारा ट्रिपल स्टोर को सबमिशन के समय भेजा जाता है, न कि निष्कर्षण पाइपलाइन के माध्यम से (`Metadata` वर्ग से हटा दिया गया। दस्तावेज़-स्तरीय मेटाडेटा ट्रिपल अब सीधे लाइब्रेरियन द्वारा ट्रिपल स्टोर को सबमिशन के समय भेजा जाता है, न कि निष्कर्षण पाइपलाइन के माध्यम से)
>>>>>>> e3bcbf73 (The metadata field (list of triples) in the pipeline Metadata class)

### बाइट्स फ़ील्ड पैटर्न (बाइट्स फ़ील्ड पैटर्न)

सभी सामग्री फ़ील्ड (`data`, `text`, `chunk`) `bytes` हैं लेकिन सभी प्रोसेसरों द्वारा तुरंत UTF-8 स्ट्रिंग में डिकोड किए जाते हैं। कोई भी प्रोसेसर कच्चे बाइट्स का उपयोग नहीं करता है।

## फ्लो कॉन्फ़िगरेशन (फ्लो कॉन्फ़िगरेशन)

फ्लो बाहरी रूप से परिभाषित किए जाते हैं और कॉन्फ़िगरेशन सेवा के माध्यम से लाइब्रेरियन को प्रदान किए जाते हैं। प्रत्येक फ्लो में निम्नलिखित निर्दिष्ट होता है:

इनपुट क्यू (इनपुट क्यू) (`text-load`, `document-load`)
प्रोसेसर श्रृंखला (प्रोसेसर श्रृंखला)
पैरामीटर (चंक आकार, निष्कर्षण विधि, आदि) (पैरामीटर (चंक आकार, निष्कर्षण विधि, आदि))

फ्लो पैटर्न के उदाहरण: (फ्लो पैटर्न के उदाहरण:)
`pdf-graphrag`: PDF → Decoder → Chunker → Definitions + Relationships → Embeddings
`text-graphrag`: Text → Chunker → Definitions + Relationships → Embeddings
`pdf-ontology`: PDF → Decoder → Chunker → Ontology Extraction → Embeddings
`text-rows`: Text → Chunker → Row Extraction → Row Store