DeepSeek-V3.2-Exp: डेमो प्रोजेक्ट के साथ एक गाइड

DeepSeek ने अभी v3.2-Exp जारी किया है—एक प्रायोगिक मॉडल जो API लागत को आधे से भी ज्यादा कम कर देता है। यदि आप बड़े भाषा मॉडलों के साथ काम कर रहे हैं, तो आप जानते हैं कि लंबा संदर्भ (long context) प्रोसेस करना तेजी से महंगा हो जाता है। यह नया रिलीज़ उसी समस्या को DeepSeek Sparse Attention नामक तकनीक से संबोधित करता है।

इस ट्यूटोरियल में, मैं बताऊंगा कि v3.2 पिछले DeepSeek संस्करणों से कैसे भिन्न है, sparse attention अंदर से कैसे काम करता है, और अपने प्रोजेक्ट्स में इस मॉडल का उपयोग कैसे करें। हम API कॉल की बुनियाद कवर करेंगे और एक डेमो प्रोजेक्ट बनाएंगे जो दिखाएगा कि यह मॉडल कहाँ सबसे बेहतर काम करता है।

अंत तक, आप एक Streamlit ऐप बनाएंगे जो अलग-अलग LLMs—DeepSeek v3.2 सहित—के बीच लागत की तुलना करता है:

मैं हमारे डेमो प्रोजेक्ट को भी देखने की सलाह देता/देती हूँ जो नए DeepSeek-V3.2-Speciale वेरिएंट को कवर करता है।

DeepSeek V3.2 क्या है?

आइए DeepSeek की पृष्ठभूमि और इस रिलीज़ में क्या बदला है, उससे शुरू करते हैं।

DeepSeek मॉडल परिवार

DeepSeek एक चीन-आधारित ओपन-सोर्स AI कंपनी है जो MIT लाइसेंस के तहत बड़े भाषा मॉडल बनाती है। इनके मॉडल GPT-5 और Claude से तर्क, कोडिंग और सामान्य प्रयोजन के कार्यों में प्रतिस्पर्धा करते हैं। पिछले वर्ष में कंपनी ने कई संस्करण जारी किए हैं, जिनमें DeepSeek-V3 और DeepSeek-R1 शामिल हैं, जो क्लोज़्ड-सोर्स विकल्पों की तुलना में कम लागत पर बेहतर प्रदर्शन के लिए सुर्खियों में रहे।

v3.2 से पहले, सबसे हालिया रिलीज़ v3.1-Terminus था, जो 685-बिलियन पैरामीटर वाला मॉडल है। प्रदर्शन अच्छा था, लेकिन लंबे संदर्भ को प्रोसेस करना अब भी महंगा था। यहीं नया प्रायोगिक रिलीज़ काम आता है।

V3.2-Exp: प्रायोगिक रिलीज़

DeepSeek ने v3.2-Exp 29 सितंबर, 2025 (2025-09-29) को जारी किया। "Exp" का अर्थ experimental है, यानी मॉडल अब भी परीक्षण और परिष्करण चरण में है। अभी प्रोडक्शन-स्तरीय स्थिरता की अपेक्षा न करें, लेकिन आप इसे रिसर्च और उन प्रोजेक्ट्स में उपयोग कर सकते हैं जहाँ आप नवीनतम फीचर्स आज़माना चाहते हैं।

यह मॉडल v3.1-Terminus पर आधारित है और वही 685B पैरामीटर आर्किटेक्चर बनाए रखता है। फर्क इसके आंतरिक प्रोसेस में है। यह OpenAI-कम्पैटिबल API फ़ॉर्मेट उपयोग करता है, तो यदि आपने पहले OpenAI SDK का उपयोग किया है, तो आप पहले से ही DeepSeek के साथ काम करना जानते हैं (मैं इस लेख में आपकी पहली API कॉल कैसे करें, यह भी समझाऊँगा/समझाऊँगी)।

मुख्य नवाचार: लागत और दक्षता

बड़ा बदलाव यह है: DeepSeek ने v3.1 की तुलना में API की कीमतें 50% से अधिक घटा दी हैं। और प्रदर्शन वही बना रहा। यानी आधी लागत पर समान गुणवत्ता की प्रतिक्रियाएँ।

यह मूल्य कटौती DeepSeek Sparse Attention (DSA) नामक तकनीकी सुधार से आई है। हर इनपुट टोकन पर ध्यान देने के बजाय (जो संगणनात्मक रूप से महंगा है), DSA चयनित रूप से महत्वपूर्ण हिस्सों पर फोकस करता है। अगला सेक्शन बताएगा कि यह कैसे काम करता है।

यदि आप पूरी तकनीकी जानकारी चाहते हैं, तो DeepSeek ने GitHub पर तकनीकी रिपोर्ट प्रकाशित की है, जिसमें आर्किटेक्चर बदलाव और बेंचमार्क परिणाम समझाए गए हैं।

DeepSeek Sparse Attention (DSA) क्या है?

कोड पर जाने से पहले, बात करते हैं कि v3.2 सस्ता और तेज़ कैसे है। जवाब इस बात में है कि मॉडल आपका इनपुट कैसे प्रोसेस करता है।

ट्रांसफॉर्मर्स में attention मैकेनिज्म: एक त्वरित परिचय

जब आप किसी भाषा मॉडल को टेक्स्ट भेजते हैं, तो वह आपके इनपुट को टोकन में तोड़ता है (लगभग शब्द या शब्दों के हिस्से)। फिर मॉडल को तय करना होता है कि कौन-से टोकन एक-दूसरे से संबंधित हैं। इस प्रक्रिया को attention कहते हैं।

पारंपरिक ट्रांसफॉर्मर्स में हर टोकन हर दूसरे टोकन को देखता है। यदि आपके पास 1,000 टोकन हैं, तो हर टोकन बाकी 999 को जाँचता है—यानी 10 लाख तुलना। 10,000 टोकन पर यह 10 करोड़ तुलना हो जाती हैं। गणित quadratic है: आप इनपुट लंबाई दोगुनी करें, तो compute लागत चार गुना हो जाती है।

इसी कारण long-context प्रोसेसिंग महंगी हो जाती है। जैसे-जैसे दस्तावेज़ लंबे होते हैं, आपकी API बिल तेजी से बढ़ती है।

Sparse attention का मतलब क्या है

हर टोकन को हर दूसरे टोकन को देखने की जरूरत नहीं होती। जब आप यह वाक्य पढ़ रहे हैं, तो आप बार-बार हर पिछले शब्द को नहीं पढ़ रहे—आप प्रासंगिक चीज़ों पर ध्यान दे रहे हैं।

Sparse attention भी यही करता है। हर टोकन की हर टोकन से तुलना करने के बजाय, मॉडल चुनता है कि कौन-सी तुलना मायने रखती है। कुछ पुराने तरीकों में शामिल हैं:

Block-sparse attention: टोकन को ब्लॉक्स में बाँटें और केवल पास-पड़ोस के ब्लॉक्स को एक-दूसरे पर ध्यान देने दें
Local window attention: हर टोकन केवल एक निश्चित दूरी के भीतर के टोकन को देखता है

ये तरीके compute बचाते हैं, लेकिन कठोर होते हैं। ये पहले से तय कर देते हैं कि कौन-से टोकन इंटरैक्ट कर सकते हैं, भले ही आपके वास्तविक टेक्स्ट की ज़रूरत कुछ और हो। कई बार दस्तावेज़ की शुरुआत का शब्द अंत की किसी चीज़ से जुड़ना चाहिए—फिक्स्ड पैटर्न यह मिस कर सकते हैं।

DeepSeek Sparse Attention (DSA): एक सूक्ष्म दृष्टिकोण

DSA अलग रास्ता अपनाता है। फिक्स्ड पैटर्न के बजाय, यह कंटेंट के आधार पर सीखता है कि किन टोकन को वास्तव में एक-दूसरे पर ध्यान देना चाहिए। मॉडल चलते-चलते प्रासंगिक कनेक्शंस चुनता है।

ऊपरी स्तर पर यह ऐसे काम करता है: ट्रेनिंग के दौरान, DeepSeek ने हर attention लेयर में एक selection मैकेनिज्म जोड़ा। यह मैकेनिज्म आपके टोकन को देखता है और तय करता है कि किन attention कनेक्शंस की गणना करना सार्थक है। यह महत्वपूर्ण कनेक्शंस रखता है और बाकी को छोड़ देता है।

यह चयन रैंडम नहीं है। मॉडल ने ट्रेनिंग के दौरान सीखा कि अलग-अलग कार्यों के लिए किस प्रकार के कनेक्शंस मायने रखते हैं। जब आप कोड से जुड़ा प्रॉम्प्ट भेजते हैं, तो यह अलग पैटर्न पर ध्यान देता है बनिस्बत किसी कानूनी दस्तावेज़ के।

नतीजा: DSA attention ऑपरेशनों की संख्या घटा देता है बिना आउटपुट गुणवत्ता पर असर डाले। तकनीकी रिपोर्ट में DeepSeek दिखाता है कि v3.2 बेंचमार्क पर लगभग v3.1-Terminus जैसा ही प्रदर्शन करता है, लेकिन प्रति टोकन कम compute करता है। आपको लगभग आधी API लागत पर वही मॉडल गुणवत्ता मिलती है।

डेवलपर्स के लिए इसका मतलब

व्यवहार में DSA का अर्थ यह है:

कम API लागत: समान गुणवत्ता की प्रतिक्रियाओं के लिए आपको कम भुगतान करना होता है
बेहतर long-context हैंडलिंग: मॉडल 128K टोकन संदर्भ विंडो सपोर्ट करता है और sparse attention न होने वाले मॉडलों की तुलना में लंबे इनपुट सस्ते में प्रोसेस करता है
तेज़ inference: कम ऑपरेशंस का मतलब तेज़ प्रतिक्रियाएँ

ये फायदे खासकर इन उपयोग मामलों में दिखते हैं:

एक साथ कई दस्तावेज़ों का विश्लेषण
लंबी बातचीत में संदर्भ बनाए रखना
बड़े कोडबेस या तकनीकी दस्तावेज़ प्रोसेस करना
रिसर्च पेपर या कानूनी कॉन्ट्रैक्ट का सार-संक्षेप

यदि आपका एप्लिकेशन लंबे इनपुट्स से डील करता है, तो DSA वास्तविक फर्क लाता है। आप केवल पैसे नहीं बचाते—आपको उन कार्यों पर बेहतर प्रदर्शन मिलता है जहाँ पारंपरिक attention जूझता है।

अपनी पहली DeepSeek V3.2 कॉल करना

अब जबकि आप समझ गए हैं कि DSA कैसे काम करता है, आइए मॉडल को इसकी API के माध्यम से उपयोग करें।

पूर्वापेक्षाएँ

आपके मशीन पर Python 3.8 या नया संस्करण इंस्टॉल होना चाहिए। यदि आप APIs के जरिए LLMs के साथ काम करने में नए हैं, तो DataCamp का AI सीखने का गाइड देख सकते हैं ताकि बुनियादी बातें समझ सकें। हमारे पास एक और विस्तृत DeepSeek API ट्यूटोरियल भी है जो पहले के संस्करण कवर करता है, यदि आप और गहराई में जाना चाहें।

अच्छी बात: यदि आपने पहले OpenAI की API का उपयोग किया है, तो आप पहले से ही DeepSeek का उपयोग करना जानते हैं। API फ़ॉर्मेट समान है।

पर्यावरण सेटअप

सबसे पहले, platform.deepseek.com से अपना API key प्राप्त करें। यदि आपका अकाउंट नहीं है, तो एक बनाना होगा।

आवश्यक पैकेज इंस्टॉल करें:

uv add openai python-dotenvसंचालित द्वारा

अपने प्रोजेक्ट डायरेक्टरी में .env फ़ाइल बनाएँ और अपना API key जोड़ें:

DEEPSEEK_API_KEY=your_api_key_hereसंचालित द्वारा

आपकी पहली API कॉल

यहाँ OpenAI SDK का एक बेसिक उदाहरण है। OpenAI की API से अंतर केवल base_url पैरामीटर और आपका API key है:

from openai import OpenAI
from dotenv import load_dotenv
import os

# Load environment variables from .env file
load_dotenv()

# Initialize OpenAI-compatible client with DeepSeek endpoint
client = OpenAI(
   api_key=os.getenv("DEEPSEEK_API_KEY"),
   base_url="https://api.deepseek.com"
)

# Send a chat completion request to DeepSeek v3.2
response = client.chat.completions.create(
   model="deepseek-chat",
   messages=[
       {"role": "user", "content": "Explain sparse attention in one sentence."}
   ]
)

# Print the model's response
print(response.choices[0].message.content)संचालित द्वारा

जब आप इसे चलाते हैं, तो आपको कुछ ऐसा जवाब मिलेगा:

Sparse attention reduces computational cost by having each token attend to only a subset of relevant tokens rather than all tokens in a sequence.संचालित द्वारा

deepseek-chat मॉडल v3.2-Exp का non-thinking मोड है। यह आपकी रिक्वेस्ट प्रोसेस करता है और बिना अपनी reasoning स्टेप्स दिखाए जवाब देता है।

reasoning मॉडल का उपयोग

यदि आप मॉडल की reasoning प्रक्रिया देखना चाहते हैं, तो deepseek-reasoner उपयोग करें। यह मॉडल अंतिम उत्तर देने से पहले अपनी chain of thought दिखाता है:

# Use deepseek-reasoner to see the model's reasoning process
response = client.chat.completions.create(
   model="deepseek-reasoner",
   messages=[
       {"role": "user", "content": "Which is larger: 9.11 or 9.8?"}
   ]
)

# Print both reasoning and final answer
print("Reasoning:", response.choices[0].message.reasoning_content)
print("Answer:", response.choices[0].message.content)संचालित द्वारा

यह कुछ ऐसा आउटपुट देगा:

Reasoning: To compare 9.11 and 9.8, I need to look at the digits after the decimal point. 9.11 has digits 1 and 1 after the decimal, making it 9 + 0.11. Meanwhile, 9.8 is 9 + 0.8. Since 0.8 is greater than 0.11, 9.8 is the larger number.

Answer: 9.8 is larger than 9.11.संचालित द्वारा

reasoning मॉडल अंतिम उत्तर देने से पहले 64K टोकन तक reasoning कंटेंट जनरेट कर सकता है (डिफ़ॉल्ट 32K)। ध्यान दें कि यह temperature या top_p जैसे कुछ पैरामीटर्स सपोर्ट नहीं करता। DeepSeek की आधिकारिक API अभी reasoning_effort पैरामीटर सपोर्ट नहीं करती जो reasoning गहराई नियंत्रित करे (हालाँकि कुछ थर्ड-पार्टी प्रोवाइडर्स जैसे LangChain ने इसे अपनी इंटीग्रेशंस में जोड़ा है)।

रेस्पॉन्स ऑब्जेक्ट OpenAI की संरचना का पालन करता है। आप कंटेंट को response.choices[0].message.content से एक्सेस कर सकते हैं, response.usage से टोकन उपयोग देख सकते हैं, और response.model से प्रयुक्त मॉडल।

DeepSeek v3.2 तक पहुँचने के अन्य तरीके

API ही एकमात्र विकल्प नहीं है। DeepSeek अपने मॉडल्स को ओपन सोर्स रूप में जारी करता है, इसलिए आप इन्हें स्वयं चला सकते हैं।

Hugging Face: मॉडल यहाँ उपलब्ध है: huggingface.co/deepseek-ai/DeepSeek-V3.2-Exp। आप Hugging Face के inference प्रोवाइडर्स से बिना इन्फ्रास्ट्रक्चर मैनेज किए मॉडल चला सकते हैं, या लोकल inference के लिए weights डाउनलोड कर सकते हैं। लोकल तरीका तभी व्यावहारिक है जब आपके पास हार्डवेयर हो (685B पैरामीटर मॉडल के लिए डेटा सेंटर बजट या एक छोटा GPU क्लस्टर सोचें)।

vLLM: बड़े पैमाने पर self-hosted डिप्लॉयमेंट के लिए, vLLM v3.2 सपोर्ट के साथ अनुकूलित inference प्रदान करता है। यह मानक transformers के जरिए मॉडल चलाने से तेज़ है और batching को अच्छी तरह संभालता है। इसे तब उपयोग करें जब आप मॉडल को प्रोडक्शन में सर्व कर रहे हों और आपके पास मजबूत इन्फ्रास्ट्रक्चर हो।

प्रत्येक तरीके का उपयोग कब करें:

API का उपयोग करें यदि आप त्वरित सेटअप चाहते हैं, इन्फ्रास्ट्रक्चर मैनेज नहीं करना चाहते, या वर्कलोड्स बदलते रहते हैं
Hugging Face inference प्रोवाइडर्स का उपयोग करें यदि आप hosted inference के लाभों के साथ अधिक प्रोवाइडर विकल्प चाहते हैं
Hugging Face weights के जरिए self-host करें यदि आपको पूर्ण नियंत्रण चाहिए, गोपनीयता आवश्यकताएँ हैं, या आप मॉडल आर्किटेक्चर के साथ प्रयोग करना चाहते हैं
vLLM का उपयोग करें यदि आप हाई-वॉल्यूम प्रोडक्शन वर्कलोड्स चला रहे हैं और हार्डवेयर बजट है

ज़्यादातर डेवलपर्स के लिए शुरुआत में API सही विकल्प है। आप जितना उपयोग करें उतना भुगतान करें, और स्केल तथा मेंटेनेंस DeepSeek संभालता है।

मल्टी-डॉक्यूमेंट रिसर्च असिस्टेंट: Long-Context प्रदर्शन की तुलना

आपने देखा कि DeepSeek v3.2 की API कैसे काम करती है और अपनी पहली कॉल भी कर ली। अब इसे वास्तविक दुनिया की तुलना में परखते हैं।

क्या DeepSeek का sparse attention वास्तव में लंबे संदर्भ प्रोसेस करते समय पैसे बचाता है? और GPT-5 तथा Claude Sonnet 4.5 की तुलना में इसका प्रदर्शन कैसा है?

इसका जवाब देने के लिए, हम एक तुलना टूल बनाएँगे जो कई रिसर्च पेपर्स को एक ही संदर्भ में लोड करता है और वही क्वेरी चारों मॉडलों को भेजता है। आप देखेंगे कि हर मॉडल की लागत कितनी है, वह कितनी तेजी से जवाब देता है, और किस तरह के उत्तर देता है।

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

Long-context मॉडल इसे सब कुछ एक साथ पढ़कर हल करते हैं। न chunking, न retrieval, न कोई मिसिंग कॉन्टेक्स्ट। आप अपने सारे दस्तावेज़ एक ही प्रॉम्प्ट में लोड करते हैं और मॉडल पूरी तस्वीर देखता है। समस्या है लागत की—पारंपरिक attention के साथ 50,000+ टोकन प्रोसेस करना बहुत जल्दी महंगा हो जाता है।

यहीं हम DeepSeek के sparse attention का परीक्षण करेंगे। हम एक एप्लिकेशन बनाएँगे जो तीन रिसर्च पेपर्स (कुल मिलाकर लगभग 57,000 टोकन) को एक ही संदर्भ में लोड करता है और चार मॉडलों—GPT-5, Claude Sonnet 4.5, DeepSeek v3.2-Exp (sparse attention के साथ) और DeepSeek v3.1-Terminus (पिछला संस्करण, बिना sparse attention)—को वही क्वेरी देता है। आप लागत, प्रतिक्रिया समय और आउटपुट गुणवत्ता का अंतर साथ-साथ देखेंगे।

तैयार एप्लिकेशन कुछ ऐसा दिखता है:

नोट: इस सेक्शन में आगे आप शुरुआत से यह एप्लिकेशन कैसे बनाना है, उसका विस्तृत विवरण पाएँगे। तुलना के परिणाम समझने के लिए इसे बनाना जरूरी नहीं है, लेकिन कोड से गुजरना आपको DeepSeek के साथ अपने long-context एप्लिकेशन बनाने के व्यावहारिक पैटर्न देगा।

एप्लिकेशन बनाना

हम इसे Streamlit ऐप के रूप में बनाएँगे, जिसमें तीन सपोर्टिंग मॉड्यूल होंगे: एक डॉक्युमेंट लोडिंग के लिए, एक मॉडल कॉन्फ़िगरेशन के लिए, और एक क्वेरी हैंडलिंग के लिए। फ्लो सरल है: PDFs लोड करें, मॉडल चुनें, सवाल पूछें और नतीजे तुलना करें।

प्रोजेक्ट डायरेक्टरी बनाएँ और डिपेंडेंसियाँ इंस्टॉल करें:

mkdir multi-document-qa
cd multi-document-qa
uv add streamlit langchain langchain-openai langchain-anthropic langchain-community pypdf tiktoken python-dotenv matplotlib pandasसंचालित द्वारा

.env फ़ाइल बनाएँ और अपने API keys जोड़ें:

OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key
DEEPSEEK_API_KEY=your_deepseek_keyसंचालित द्वारा

attention मैकेनिज्म पर तीन रिसर्च पेपर्स डाउनलोड करें:

mkdir documents
cd documents
curl -L -o selective-attention.pdf "https://arxiv.org/pdf/2410.02703"
curl -L -o differential-transformer.pdf "https://arxiv.org/pdf/2410.05258"
curl -L -o sparse-attention-long-range.pdf "https://arxiv.org/pdf/2406.16747"
cd ..संचालित द्वारा

इन तीन पेपर्स को लोड करने पर कुल 57,204 टोकन होते हैं।

लोडिंग और टोकन गिनना

document_loader.py बनाएँ:

from langchain_community.document_loaders import PyPDFLoader
import tiktoken
from pathlib import Path


def load_documents(documents_dir="documents"):
   docs_path = Path(documents_dir)
   pdf_files = list(docs_path.glob("*.pdf"))
  
   all_text = ""
   document_names = []
  
   # Load each PDF and concatenate with separators
   for pdf_file in sorted(pdf_files):
       loader = PyPDFLoader(str(pdf_file))
       pages = loader.load()
       doc_text = "\n\n".join([page.page_content for page in pages])
       all_text += f"\n\n=== Document: {pdf_file.name} ===\n\n{doc_text}"
       document_names.append(pdf_file.name)संचालित द्वारा

यह फ़ंक्शन डायरेक्टरी से सभी PDFs लोड करता है, हर पेज से टेक्स्ट निकालता है, और दस्तावेज़ सेपरेटर के साथ सब कुछ जोड़ देता है।

# Count tokens using GPT-4 encoding (accurate across providers)
   encoding = tiktoken.encoding_for_model("gpt-4")
   token_count = len(encoding.encode(all_text))
  
   return all_text, token_count, document_namesसंचालित द्वारा

टोकन गिनने के लिए tiktoken के GPT-4 encoding का उपयोग किया गया है, जो सभी प्रोवाइडर्स में सटीक अनुमान देता है क्योंकि उनका tokenization समान होता है। पूरा document_loader.py GitHub पर देखें।

मॉडल्स और प्राइसिंग कॉन्फ़िगर करना

model_config.py बनाएँ:

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
import os


# Pricing per million tokens (as of October 2025)
MODEL_PRICING = {
   "gpt-5": {"input": 2.50, "output": 10.00, "name": "GPT-5"},
   "claude-sonnet-4-5-20250929": {"input": 3.00, "output": 15.00, "name": "Claude Sonnet 4.5"},
   "deepseek-chat": {"input": 0.28, "output": 0.42, "name": "DeepSeek v3.2-Exp"},
   "deepseek-chat-v3.1": {"input": 0.55, "output": 2.19, "name": "DeepSeek v3.1-Terminus"},
}संचालित द्वारा

यह प्राइसिंग डिक्शनरी प्रति मिलियन टोकन (अक्टूबर 2025 तक) की लागत रखती है। Sparse attention के साथ DeepSeek v3.2, GPT-5 और Claude की तुलना में लगभग 10x सस्ता है, जबकि v3.1 v3.2 की लागत से 2x पर बैठता है।

def get_model(model_name):
   """Initialize a chat model by name using LangChain's unified interface."""
   if model_name == "gpt-5":
       return ChatOpenAI(model="gpt-5", temperature=0, api_key=os.getenv("OPENAI_API_KEY"))
   elif model_name == "claude-sonnet-4-5-20250929":
       return ChatAnthropic(model="claude-sonnet-4-5-20250929", temperature=0,
                          api_key=os.getenv("ANTHROPIC_API_KEY"))
   elif model_name == "deepseek-chat":
       return ChatOpenAI(model="deepseek-chat", temperature=0,
                        api_key=os.getenv("DEEPSEEK_API_KEY"),
                        base_url="https://api.deepseek.com")
   elif model_name == "deepseek-chat-v3.1":
       # Note: v3.1-Terminus endpoint expires on October 15, 2025
       return ChatOpenAI(model="deepseek-chat", temperature=0,
                        api_key=os.getenv("DEEPSEEK_API_KEY"),
                        base_url="https://api.deepseek.com/v3.1_terminus_expires_on_20251015")


def calculate_cost(model_name, input_tokens, output_tokens):
   """Calculate total cost based on input and output token usage."""
   pricing = MODEL_PRICING[model_name]
   input_cost = (input_tokens / 1_000_000) * pricing["input"]
   output_cost = (output_tokens / 1_000_000) * pricing["output"]
   return input_cost + output_costसंचालित द्वारा

get_model() फ़ंक्शन LangChain के यूनिफ़ाइड इंटरफ़ेस से हर मॉडल को इनिशियलाइज़ करता है। DeepSeek मॉडल OpenAI-कम्पैटिबल एंडपॉइंट्स को कस्टम base URLs के साथ उपयोग करते हैं। नोट: v3.1-Terminus एंडपॉइंट 15 अक्टूबर, 2025 को एक्सपायर होगा। पूरा model_config.py GitHub पर है।

मेट्रिक्स ट्रैकिंग के साथ मॉडलों से क्वेरी करना

query_handler.py बनाएँ:

import time
from langchain_core.messages import SystemMessage, HumanMessage
from model_config import get_model, calculate_cost, MODEL_PRICING


def query_model(model_name, context, question):
   """Query a model with document context and track performance metrics."""
   model = get_model(model_name)
  
   # Embed full document context in system prompt
   system_prompt = f"""Use the given context to answer the question.
If you don't know the answer, say you don't know. Keep the answer concise.

Context:
{context}"""
  
   messages = [
       SystemMessage(content=system_prompt),
       HumanMessage(content=question)
   ]
  
   # Track response time
   start_time = time.time()संचालित द्वारा

सिस्टम प्रॉम्प्ट में सभी 57,000 टोकन के दस्तावेज़ एम्बेड होते हैं। पारंपरिक attention हर टोकन को हर टोकन के खिलाफ प्रोसेस करता है। DeepSeek v3.2 का sparse attention अप्रासंगिक कनेक्शंस को छोड़ देता है, जिससे लागत घटती है।

try:
       response = model.invoke(messages)
       elapsed_time = time.time() - start_time
      
       # Extract token usage (different providers use different formats)
       if hasattr(response, 'response_metadata') and 'token_usage' in response.response_metadata:
           token_usage = response.response_metadata['token_usage']
           input_tokens = token_usage.get('prompt_tokens', 0)
           output_tokens = token_usage.get('completion_tokens', 0)
       elif hasattr(response, 'usage_metadata'):
           input_tokens = response.usage_metadata.get('input_tokens', 0)
           output_tokens = response.usage_metadata.get('output_tokens', 0)
      
       # Calculate total cost
       cost = calculate_cost(model_name, input_tokens, output_tokens)
      
       return {
           "model": MODEL_PRICING[model_name]["name"],
           "response": response.content,
           "input_tokens": input_tokens,
           "output_tokens": output_tokens,
           "total_tokens": input_tokens + output_tokens,
           "cost": cost,
           "time": elapsed_time,
           "error": None
       }संचालित द्वारा

अलग-अलग LangChain इंटीग्रेशंस टोकन उपयोग अलग फ़ॉर्मेट में लौटाते हैं (OpenAI response_metadata का, Anthropic usage_metadata का)—इसलिए हम दोनों जाँचते हैं। फ़ंक्शन समय ट्रैक करता है, टोकन काउंट निकालता है, लागत की गणना करता है और सभी मेट्रिक्स के साथ एक डिक्शनरी लौटाता है। पूरा query_handler.py GitHub पर देखें।

Streamlit इंटरफ़ेस बनाना

app.py बनाएँ:

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt
from document_loader import load_documents
from query_handler import query_model
from dotenv import load_dotenv

# Load API keys from .env file
load_dotenv()

# Configure Streamlit page with wide layout
st.set_page_config(
   page_title="Multi-Document Research Assistant",
   page_icon="📚",
   layout="wide"
)

st.title("📚 Multi-Document Research Assistant")
st.markdown("Compare long-context performance across GPT-5, Claude Sonnet 4.5, DeepSeek v3.2, and DeepSeek v3.1")संचालित द्वारा

स्टैंडर्ड Streamlit सेटअप, साइड-बाय-साइड तुलना के लिए वाइड लेआउट के साथ।

# Sidebar for document loading
with st.sidebar:
   st.header("📄 Documents Loaded")
  
   if st.button("Load Documents"):
       with st.spinner("Loading documents..."):
           # Load all PDFs and count tokens
           context, token_count, doc_names = load_documents("documents")
           st.session_state.context = context
           st.session_state.token_count = token_count
           st.session_state.doc_names = doc_names
  
   # Display loaded documents info
   if "token_count" in st.session_state:
       st.success(f"✅ Loaded {len(st.session_state.doc_names)} documents")
       st.metric("Total Tokens", f"{st.session_state.token_count:,}")
       st.write("**Documents:**")
       for name in st.session_state.doc_names:
           st.write(f"• {name}")संचालित द्वारा

साइडबार दस्तावेज़ लोड करता है और टोकन काउंट दिखाता है। Streamlit का सेशन स्टेट इंटरैक्शंस के बीच डॉक्युमेंट्स को लोडेड रखता है।

# Main content area
if "context" not in st.session_state:
   st.info("👈 Click 'Load Documents' in the sidebar to begin")
else:
   st.subheader("Select Models to Compare")
   col1, col2, col3, col4 = st.columns(4)
  
   # Model selection checkboxes
   with col1:
       use_gpt5 = st.checkbox("GPT-5", value=True)
   with col2:
       use_claude = st.checkbox("Claude Sonnet 4.5", value=True)
   with col3:
       use_deepseek_v32 = st.checkbox("DeepSeek v3.2-Exp", value=True)
   with col4:
       use_deepseek_v31 = st.checkbox("DeepSeek v3.1-Terminus", value=True)
  
   # Sample questions for quick testing
   sample_questions = [
       "Compare the main approaches to attention mechanisms described in these documents",
       "What are the key differences between sparse and dense attention?",
       "Summarize the common themes across all documents"
   ]संचालित द्वारा

चार चेकबॉक्स मॉडल चयन के लिए और पूर्वनिर्धारित सैंपल प्रश्न।

# Question input with samples
   question_choice = st.selectbox(
       "Select a sample question or write your own:",
       ["Custom"] + sample_questions
   )
  
   if question_choice == "Custom":
       question = st.text_area("Enter your question:", height=100)
   else:
       question = st.text_area("Enter your question:", value=question_choice, height=100)
  
   # Query button and model execution
   if st.button("🚀 Query Models", type="primary"):
       if not question:
           st.error("Please enter a question")
       else:
           # Build list of selected models
           selected_models = []
           if use_gpt5:
               selected_models.append("gpt-5")
           if use_claude:
               selected_models.append("claude-sonnet-4-5-20250929")
           if use_deepseek_v32:
               selected_models.append("deepseek-chat")
           if use_deepseek_v31:
               selected_models.append("deepseek-chat-v3.1")संचालित द्वारा

उपयोगकर्ता सैंपल प्रश्न चुनते हैं या अपना लिखते हैं, फिर “Query Models” पर क्लिक कर चुने गए मॉडलों पर तुलना चलाते हैं।

results = []
          
           # Query each model sequentially with progress indicator
           for model_name in selected_models:
               with st.spinner(f"Querying {model_name}..."):
                   result = query_model(
                       model_name,
                       st.session_state.context,
                       question
                   )
                   results.append(result)
          
           # Store results in session state for persistence
           st.session_state.results = resultsसंचालित द्वारा

हर मॉडल को क्रमवार क्वेरी किया जाता है और स्पिनर प्रोग्रेस दिखाता है।

# Display results if available
if "results" in st.session_state:
   st.divider()
   st.subheader("📊 Results")
  
   results = st.session_state.results
  
   # Show model responses in expandable panels
   st.markdown("### Responses")
   for result in results:
       with st.expander(f"**{result['model']}** - ${result['cost']:.4f} | {result['time']:.2f}s"):
           if result['error']:
               st.error(f"Error: {result['error']}")
           else:
               st.write(result['response'])
  
   # Create metrics comparison table
   metrics_df = pd.DataFrame([
       {
           "Model": r['model'],
           "Input Tokens": r['input_tokens'],
           "Output Tokens": r['output_tokens'],
           "Total Tokens": r['total_tokens'],
           "Cost ($)": f"${r['cost']:.4f}",
           "Time (s)": f"{r['time']:.2f}"
       }
       for r in results
   ])
  
   st.dataframe(metrics_df, use_container_width=True)संचालित द्वारा

परिणाम एक्सपैंडेबल पैनल में दिखते हैं, हेडर में लागत और समय के साथ, और नीचे सॉर्टेबल मेट्रिक्स टेबल।

# Create visualization charts
   fig, axes = plt.subplots(2, 2, figsize=(12, 10))
  
   # Chart 1: Cost comparison bar chart
   axes[0, 0].bar([r['model'] for r in results], [r['cost'] for r in results],
                  color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'][:len(results)])
   axes[0, 0].set_title('Cost Comparison')
   axes[0, 0].set_ylabel('Cost ($)')
   axes[0, 0].tick_params(axis='x', rotation=45)
  
   # Chart 2: Response time bar chart
   axes[0, 1].bar([r['model'] for r in results], [r['time'] for r in results],
                  color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'][:len(results)])
   axes[0, 1].set_title('Response Time Comparison')
   axes[0, 1].set_ylabel('Time (seconds)')
  
   # Chart 3: Token usage grouped bar chart
   models = [r['model'] for r in results]
   input_tokens = [r['input_tokens'] for r in results]
   output_tokens = [r['output_tokens'] for r in results]
   x = range(len(models))
   width = 0.35
   axes[1, 0].bar([i - width/2 for i in x], input_tokens, width, label='Input', color='#1f77b4')
   axes[1, 0].bar([i + width/2 for i in x], output_tokens, width, label='Output', color='#ff7f0e')
   axes[1, 0].set_title('Token Usage Comparison')
   axes[1, 0].legend()संचालित द्वारा

चार matplotlib चार्ट 2x2 ग्रिड में: लागत बार, समय बार, ग्रुप्ड टोकन उपयोग बार और लागत-बनाम-समय स्कैटर प्लॉट।

# Chart 4: Cost vs time tradeoff scatter plot
   axes[1, 1].scatter([r['cost'] for r in results], [r['time'] for r in results],
                      s=100, alpha=0.6, color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'][:len(results)])
   for i, r in enumerate(results):
       axes[1, 1].annotate(r['model'], (r['cost'], r['time']), fontsize=8, ha='right')
   axes[1, 1].set_title('Cost vs Time Trade-off')
   axes[1, 1].set_xlabel('Cost ($)')
   axes[1, 1].set_ylabel('Time (seconds)')
   axes[1, 1].grid(True, alpha=0.3)
  
   plt.tight_layout()
   st.pyplot(fig)
  
   # Display key findings
   if len(results) > 1:
       cheapest = min(results, key=lambda x: x['cost'])
       fastest = min(results, key=lambda x: x['time'])
      
       col1, col2 = st.columns(2)
       with col1:
           st.metric("Most Cost-Effective", cheapest['model'], f"${cheapest['cost']:.4f}")
       with col2:
           st.metric("Fastest Response", fastest['model'], f"{fastest['time']:.2f}s")संचालित द्वारा

मुख्य निष्कर्ष स्वचालित रूप से सबसे सस्ते और सबसे तेज़ मॉडल को हाइलाइट करते हैं। पूरा app.py GitHub पर देखें।

तुलना चलाना

ऐप शुरू करें:

streamlit run app.pyसंचालित द्वारा

“Load Documents” पर क्लिक कर तीनों PDFs (कुल 57,204 टोकन) लोड करें। तुलना के लिए मॉडल चुनें (डिफ़ॉल्ट रूप से सभी चार), कोई प्रश्न चुनें या लिखें, फिर “Query Models” पर क्लिक करें।

57,000-टोकन संदर्भ के लिए अपेक्षित प्रतिक्रिया समय:

Claude Sonnet 4.5: 15–20 सेकंड
DeepSeek v3.2: 30–35 सेकंड
DeepSeek v3.1: 35–40 सेकंड
GPT-5: 40–45 सेकंड

परिणाम: लागत और प्रदर्शन विश्लेषण

GPT-5 ने 56,937 इनपुट टोकन प्रोसेस किए और 1,996 आउटपुट टोकन बनाए—$0.1623 में 42.28 सेकंड में। Claude Sonnet 4.5 ने 65,855 इनपुट टोकन प्रोसेस किए और 485 आउटपुट टोकन बनाए—$0.2048 में 16.13 सेकंड में—सबसे तेज़ लेकिन सबसे महंगा। DeepSeek v3.2-Exp ने 56,842 इनपुट टोकन प्रोसेस किए और 698 आउटपुट टोकन बनाए—सिर्फ $0.0162 में 32.16 सेकंड में। DeepSeek v3.1-Terminus ने 56,842 इनपुट टोकन प्रोसेस किए और 700 आउटपुट टोकन बनाए—$0.0328 में 35.85 सेकंड में।

v3.1 और v3.2 की तुलना sparse attention के प्रभाव को दिखाती है। दोनों ने समान इनपुट प्रोसेस किए और लगभग समान आउटपुट दिए (698 बनाम 700 टोकन), लेकिन v3.2 की लागत आधी रही ($0.0162 बनाम $0.0328) और यह थोड़ा तेज़ चला (32.16s बनाम 35.85s)। यानी केवल sparse attention से 2x लागत कमी।

GPT-5 और Claude की तुलना में, v3.2 GPT-5 से 10x सस्ता है ($0.0162 बनाम $0.1623) और Claude से 13x सस्ता ($0.0162 बनाम $0.2048)। इसी लंबाई की 100 क्वेरीज़ पर, DeepSeek v3.2 के साथ आपकी लागत $16.20 होगी, जबकि GPT-5 के साथ $162.30 या Claude के साथ $204.80।

चार्ट्स पुष्टि करते हैं कि लागत-बनाम-समय ट्रेडऑफ के निचले-बाएँ क्वाड्रंट में DeepSeek v3.2 आता है: कुल मिलाकर सबसे सस्ता ($0.0162) और 32 सेकंड पर उचित गति बनाए रखता है। Claude गति के लिए लागत का सौदा करता है (तेज़ लेकिन महंगा), GPT-5 दोनों मीट्रिक्स पर पीछे रहता है (महंगा और सबसे धीमा), और v3.1 बीच में है। टोकन उपयोग चार्ट दिखाता है कि सभी मॉडल समान इनपुट आकार प्रोसेस करते हैं, लेकिन आउटपुट लंबाई बदलती है—GPT-5 ने 1,996 टोकन के साथ सबसे लंबा उत्तर बनाया, Claude ने 485 टोकन पर संक्षिप्त रखा, और दोनों DeepSeek वर्ज़न ने लगभग 700 टोकन के आसपास समान आउटपुट दिए।

यह तरीका कब उपयुक्त है

पूर्ण दस्तावेज़ संदर्भ में लोड करना तब सबसे बेहतर काम करता है जब आपको क्रॉस-डॉक्यूमेंट समझ चाहिए। यदि आपका सवाल तीन अलग-अलग पेपर्स के विचारों को जोड़ने की मांग करता है, तो chunking और retrieval वे कनेक्शंस मिस कर सकते हैं। मॉडल को एक साथ सब कुछ देखना चाहिए।

यह पैटर्न कई उपयोग मामलों में फिट बैठता है:

रिसर्च और विश्लेषण: कई पेपर्स, रिपोर्ट्स या लेखों की तुलना जहाँ रिश्ते खास मायने रखते हैं, केवल तथ्य नहीं।
कानूनी दस्तावेज़ समीक्षा: कॉन्ट्रैक्ट तुलना, नीति विश्लेषण या विनियामक समीक्षा, जहाँ संदर्भ और सूक्ष्म अंतर महत्वपूर्ण होते हैं।
तकनीकी दस्तावेज़ीकरण: अलग-अलग API डॉक्स या तकनीकी विनिर्देश एक-दूसरे से कैसे संबंधित हैं, यह समझना।
लंबे-फॉर्म का निर्माण: कई स्रोतों से जानकारी समेकित करते हुए यह जानना कि हर स्रोत क्या कहता है।

यह तरीका तब अच्छा नहीं काम करता जब:

दस्तावेज़ बहुत बड़े हों: अधिकांश मॉडल 128K–200K टोकन पर कैप करते हैं। इससे बड़े पर आपको chunking चाहिए।
आप तथ्यों की खोज कर रहे हों: “X का उत्तर खोजें” जैसे प्रश्नों के लिए retrieval के साथ RAG बेहतर है, जहाँ जानकारी किसी विशेष सेक्शन में होने की जानकारी है।
आपके पास बहुत-से दस्तावेज़ हों: 20 दस्तावेज़ पूर्ण लंबाई में लोड करना संदर्भ सीमाएँ पार कर सकता है। पहले फ़िल्टर करने वाली हाइब्रिड पद्धतियों पर विचार करें।
बजट असीमित हो: यदि लागत मायने नहीं रखती, तो जटिल क्वेरीज़ के लिए GPT-5 या Claude थोड़े बेहतर उत्तर दे सकते हैं।

DeepSeek का sparse attention long-context प्रोसेसिंग की अर्थव्यवस्था बदल देता है। जो पहले प्रति क्वेरी $0.15–0.20 लगता था, अब $0.01–0.02 में होता है। इससे फुल-कॉन्टेक्स्ट तरीके उन एप्लिकेशंस के लिए व्यावहारिक हो जाते हैं जो रोज़ाना सैकड़ों या हज़ारों क्वेरी चलाते हैं।

निष्कर्ष

DeepSeek v3.2 का sparse attention v3.1 की तुलना में आधी लागत पर वही मॉडल गुणवत्ता देता है। हमने जो मल्टी-डॉक्यूमेंट तुलना बनाई, उसने इसे व्यावहार में दिखाया। 57,000 टोकन प्रोसेस करना v3.2 के साथ $0.0162 में हुआ, जबकि v3.1 के साथ $0.0328—और दोनों ने लगभग समान आउटपुट दिए। GPT-5 और Claude की तुलना में, v3.2 10–13x सस्ता है और प्रतिक्रिया समय भी उचित रखता है। लंबा संदर्भ नियमित रूप से प्रोसेस करने वाले एप्लिकेशंस के लिए, ये बचत तेजी से जुड़ती हैं।

यदि आप दस्तावेज़ विश्लेषण, रिसर्च टूल्स, या किसी भी ऐसे एप्लिकेशन पर काम कर रहे हैं जो लंबे संदर्भ से डील करता है, तो v3.2 परीक्षण के योग्य है। बस याद रखें कि यह अभी प्रायोगिक है, इसलिए प्रोडक्शन में लगाने से पहले अच्छे से टेस्ट करें।

AI में नवीनतम जानकारी के लिए ये ब्लॉग देखें:

लेखक

Bexruz (Bex) Tuychiev

मैं 2 से अधिक वर्षों के अनुभव वाला डेटा साइंस कंटेंट क्रिएटर हूँ और Medium पर सबसे बड़े फॉलोइंग्स में से एक रखता हूँ। मुझे एआई और एमएल पर विस्तार से लेख लिखना पसंद है, जिसमें हल्का-सा व्यंग्यात्मक अंदाज रहता है—क्योंकि कुछ तो करना पड़ता है ताकि वे कम उबाऊ लगें। मैंने 130 से अधिक लेख और एक DataCamp कोर्स तैयार किया है, और एक और बन रहा है। मेरा कंटेंट 50 लाख से अधिक लोगों ने देखा है, जिनमें से 20 हज़ार लोग Medium और LinkedIn पर फॉलोअर्स बन गए।

विषय

कृत्रिम बुद्धिमत्ता बड़े भाषा मॉडल