mirror of
https://github.com/trustgraph-ai/trustgraph.git
synced 2026-04-26 08:56:21 +02:00
355 lines
24 KiB
Markdown
355 lines
24 KiB
Markdown
---
|
|
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
|