अरे दोस्तों! ?

तुम्हें पता है मुझे रात में जागने में क्या दिक्कत होती है? इस बारे में सोच रहे हैं कि हमारे एआई सिस्टम को कैसे अधिक स्मार्ट और अधिक कुशल बनाया जाए। आज, मैं उस चीज़ के बारे में बात करना चाहता हूं जो बुनियादी लग सकती है लेकिन किक-अस एआई अनुप्रयोगों का निर्माण करते समय महत्वपूर्ण है: chunking ✨।

आख़िर क्या गड़बड़ हो रही है? ?

चंकिंग को अपने एआई के तरीके के रूप में सोचें, जिसमें सूचना के एक विशाल समूह को प्रबंधनीय, छोटे आकार के भागों में विभाजित किया जा सकता है। ठीक उसी तरह जैसे आप एक बार में पूरा पिज़्ज़ा अपने मुँह में भरने की कोशिश नहीं करेंगे (या शायद आप करेंगे, यहाँ कोई निर्णय नहीं!), आपके एआई को प्रभावी ढंग से संसाधित करने के लिए बड़े पाठों को छोटे टुकड़ों में तोड़ने की ज़रूरत है।

यह विशेष रूप से उसके लिए महत्वपूर्ण है जिसे हम RAG (रिट्रीवल-ऑगमेंटेड जेनरेशन) मॉडल कहते हैं। ये बुरे लड़के सिर्फ बातें नहीं बनाते - वे वास्तव में जाते हैं और बाहरी स्रोतों से वास्तविक जानकारी लाते हैं। बहुत साफ-सुथरा, है ना?

आपको परवाह क्यों करनी चाहिए? ?

देखिए, यदि आप कुछ भी बना रहे हैं जो टेक्स्ट से संबंधित है - चाहे वह ग्राहक सहायता चैटबॉट हो या फैंसी ज्ञान आधार खोज - सही ढंग से चर्चा करना एक एआई के बीच का अंतर है जो स्पॉट-ऑन उत्तर देता है और एक ऐसा एआई जो सिर्फ... . मेह.

बहुत बड़े टुकड़े? आपका मॉडल मुद्दा भूल गया है।
बहुत छोटे टुकड़े? यह विवरण में खो जाता है।

आइए अपने हाथ गंदे करें: वास्तविक उदाहरण?

पायथन उदाहरण: सिमेंटिक चंकिंग

सबसे पहले, आइए सिमेंटिक चंकिंग के लिए लैंगचेन का उपयोग करते हुए एक पायथन उदाहरण देखें:

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import TextLoader

def semantic_chunk(file_path):
    # Load the document
    loader = TextLoader(file_path)
    document = loader.load()

    # Create a text splitter
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=200,
        length_function=len,
        separators=["\n\n", "\n", " ", ""]
    )

    # Split the document into chunks
    chunks = text_splitter.split_documents(document)

    return chunks

# Example usage
chunks = semantic_chunk('knowledge_base.txt')
for i, chunk in enumerate(chunks):
    print(f"Chunk {i}: {chunk.page_content[:50]}...")

Node.js और CDK उदाहरण: एक ज्ञानकोष का निर्माण

अब, आइए कुछ वास्तविक बनाएं - AWS CDK और Node.js का उपयोग करके एक सर्वर रहित ज्ञानकोष! ?

सबसे पहले, सीडीके बुनियादी ढांचा (यह वह जगह है जहां जादू होता है):

import * as cdk from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as opensearch from 'aws-cdk-lib/aws-opensearch';
import * as iam from 'aws-cdk-lib/aws-iam';

export class KnowledgeBaseStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // S3 bucket to store our documents
    const documentBucket = new s3.Bucket(this, 'DocumentBucket', {
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });

    // OpenSearch domain for storing our chunks
    const openSearchDomain = new opensearch.Domain(this, 'DocumentSearch', {
      version: opensearch.EngineVersion.OPENSEARCH_2_5,
      capacity: {
        dataNodes: 1,
        dataNodeInstanceType: 't3.small.search',
      },
      ebs: {
        volumeSize: 10,
      },
    });

    // Lambda function for processing documents
    const processorFunction = new lambda.Function(this, 'ProcessorFunction', {
      runtime: lambda.Runtime.NODEJS_18_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset('lambda'),
      environment: {
        OPENSEARCH_DOMAIN: openSearchDomain.domainEndpoint,
      },
      timeout: cdk.Duration.minutes(5),
    });

    // Grant permissions
    documentBucket.grantRead(processorFunction);
    openSearchDomain.grantWrite(processorFunction);
  }
}

और अब, लैम्ब्डा फ़ंक्शन जो चंकिंग और इंडेक्सिंग करता है:

import { S3Event } from 'aws-lambda';
import { S3 } from 'aws-sdk';
import { Client } from '@opensearch-project/opensearch';
import { defaultProvider } from '@aws-sdk/credential-provider-node';
import { AwsSigv4Signer } from '@opensearch-project/opensearch/aws';

const s3 = new S3();
const CHUNK_SIZE = 1000;
const CHUNK_OVERLAP = 200;

// Create OpenSearch client
const client = new Client({
  ...AwsSigv4Signer({
    region: process.env.AWS_REGION,
    service: 'es',
    getCredentials: () => {
      const credentialsProvider = defaultProvider();
      return credentialsProvider();
    },
  }),
  node: `https://${process.env.OPENSEARCH_DOMAIN}`,
});

export const handler = async (event: S3Event) => {
  for (const record of event.Records) {
    const bucket = record.s3.bucket.name;
    const key = decodeURIComponent(record.s3.object.key.replace(/\ /g, ' '));

    // Get the document from S3
    const { Body } = await s3.getObject({ Bucket: bucket, Key: key }).promise();
    const text = Body.toString('utf-8');

    // Chunk the document
    const chunks = chunkText(text);

    // Index chunks in OpenSearch
    for (const [index, chunk] of chunks.entries()) {
      await client.index({
        index: 'knowledge-base',
        body: {
          content: chunk,
          documentKey: key,
          chunkIndex: index,
          timestamp: new Date().toISOString(),
        },
      });
    }
  }
};

function chunkText(text: string): string[] {
  const chunks: string[] = [];
  let start = 0;

  while (start 




  
  
  यह सब एक साथ कैसे काम करता है?



दस्तावेज़ अपलोड: जब आप S3 बकेट में कोई दस्तावेज़ अपलोड करते हैं, तो यह हमारे लैम्ब्डा फ़ंक्शन को ट्रिगर करता है।

प्रसंस्करण: लैम्ब्डा फ़ंक्शन:

S3 से दस्तावेज़ पुनर्प्राप्त करता है
हमारे स्मार्ट चंकिंग एल्गोरिदम का उपयोग करके इसे खंडित करता है
ओपनसर्च में प्रत्येक भाग को मेटाडेटा के साथ अनुक्रमित करता है


पुनर्प्राप्ति: बाद में, जब आपके एप्लिकेशन को जानकारी ढूंढने की आवश्यकता होती है, तो यह सबसे प्रासंगिक खंड ढूंढने के लिए ओपनसर्च से पूछताछ कर सकता है।
यहां एक त्वरित उदाहरण दिया गया है कि आप इस ज्ञानकोष से कैसे पूछताछ कर सकते हैं:


async function queryKnowledgeBase(query: string) {
  const response = await client.search({
    index: 'knowledge-base',
    body: {
      query: {
        multi_match: {
          query: query,
          fields: ['content'],
        },
      },
    },
  });

  return response.body.hits.hits.map(hit => ({
    content: hit._source.content,
    documentKey: hit._source.documentKey,
    score: hit._score,
  }));
}





  
  
  AWS लाभ ?️


S3, Lambda, और OpenSearch जैसी AWS सेवाओं का उपयोग करने से हमें यह मिलता है:

• सर्वर रहित स्केलेबिलिटी (प्रबंधन के लिए कोई सर्वर नहीं!)
• प्रति-उपयोग मूल्य निर्धारण (आपका बटुआ आपको धन्यवाद देगा)
• प्रबंधित सेवाएँ (कम ऑप्स कार्य = अधिक कोडिंग मज़ेदार)

अंतिम विचार?

साथियों ये रहा आपके लिए! सर्वर रहित ज्ञानकोष में चंकिंग को कैसे कार्यान्वित किया जाए इसका एक वास्तविक दुनिया का उदाहरण। श्रेष्ठ भाग? यह स्वचालित रूप से स्केल करता है और किसी भी आकार के दस्तावेज़ों को संभाल सकता है।

याद रखें, अच्छी चंकिंग की कुंजी है:

1. अपने उपयोग के मामले के लिए सही टुकड़े का आकार चुनें
2. संदर्भ बनाए रखने के लिए ओवरलैप पर विचार करें
3. जब संभव हो तो प्राकृतिक सीमाओं का उपयोग करें (जैसे वाक्य या पैराग्राफ)

ज्ञानकोष के निर्माण में आपका अनुभव क्या है? क्या आपने अलग-अलग चंकिंग रणनीतियाँ आज़माई हैं? मुझे नीचे टिप्पणी में बताये! ?