MCP कैसे काम करता है? Claude और AI एजेंट्स के पर्दे के पीछे की पूरी कहानी

जब Claude अपने आप कोई फ़ाइल पढ़ता है या इमेज API कॉल करता है, तो Model Context Protocol जादू जैसा लगता है। यह आर्टिकल उसे खोलकर दिखाता है: होस्ट, क्लाइंट और सर्वर, JSON-RPC हैंडशेक, टूल्स बनाम रिसोर्सेज़ बनाम प्रॉम्प्ट्स, टूल कॉल्स को दोहराने वाला एजेंट लूप, और वे सुरक्षा जाँचें जो इसे सुरक्षित रखती हैं।

क्रिएटर्स के लिए AI आज़माएँ

MCP कैसे काम करता है? Claude और AI एजेंट्स के पर्दे के पीछे की पूरी कहानी

लेखक: Cristian Da Conceicao

Picasso IA के संस्थापक

10 अक्टूबर 2026 - 8:58 pm

आप एक अनुरोध टाइप करते हैं, Claude एक फ़ाइल पढ़ता है, डेटाबेस से पूछताछ करता है, या इमेज रेंडर करता है, और कुछ सेकंड बाद नतीजा चैट में आ जाता है। मॉडल के वेट्स के अंदर कुछ भी नहीं जानता कि आपके डेटाबेस तक कैसे पहुँचा जाए। बीच में कुछ और है, और वह है Model Context Protocol, जिसे संक्षेप में MCP कहा जाता है। अगर आपने कभी पूछा है कि पर्दे के पीछे MCP कैसे काम करता है, तो संक्षेप में बात यह है: एक साझा मैसेज फ़ॉर्मेट AI एप्लिकेशन को बाहरी प्रोग्रामों से पूछने देता है कि वे क्या कर सकते हैं, और फिर मॉडल की ओर से उन्हें कॉल करता है। इस आर्टिकल का बाकी हिस्सा एक अनुरोध को पहले हैंडशेक से लेकर आख़िरी टूल नतीजे तक ट्रेस करता है, असली मैसेज शेप के साथ, ताकि आप हर हॉप की कल्पना कर सकें।

MCP असल में क्या है

MCP एक ओपन स्टैंडर्ड है जिसे Anthropic ने नवंबर 2024 में पेश किया था। यह बताता है कि AI एप्लिकेशन बाहरी टूल्स और डेटा से कैसे जुड़ता है, एक साझा नियमों के सेट के ज़रिए, न कि हर प्रोडक्ट-जोड़ी के लिए अलग इंटीग्रेशन के बजाय। सोचिए कि USB-C एक ही केबल से माइक्रोफ़ोन, ड्राइव और मॉनिटर को कैसे जोड़ देता है। MCP लैंग्वेज मॉडल और उनके आसपास के सॉफ़्टवेयर के बीच यही भूमिका निभाता है।

यह किस समस्या को हल करता है

ओक की वर्कबेंच पर उलझी हुई बेमेल केबलों और चार्जरों का ढेर, ऊपर से देखा गया

MCP से पहले, हर AI ऐप जो कैलेंडर पढ़ना, कोडबेस खोजना, या इमेज API कॉल करना चाहता था, उसे अपना अलग glue code चाहिए था। N एप्लिकेशन और M टूल्स के साथ, टीमों को अधिकतम N × M अलग-अलग इंटीग्रेशन संभालने पड़ते थे, हर एक के अलग-अलग authentication व्यवहार, error फ़ॉर्मेट और अपडेट का शेड्यूल। एक कनेक्टर में ठीक किया गया बग बाकी किसी के काम नहीं आता था, और हर नया मॉडल या टूल काम को और बढ़ा देता था।

एक प्रोटोकॉल क्यों जीतता है

सफ़ेद यूनिवर्सल ट्रैवल पावर एडैप्टर पकड़े हुए हाथ, जिसमें कई प्लग टाइप हैं

एक साझा प्रोटोकॉल गणित को N × M से N + M में बदल देता है। एक टूल लेखक एक सर्वर लिखता है। एक एप्लिकेशन लेखक एक क्लाइंट लिखता है। बाकी सब बिना अतिरिक्त कोड के जुड़ जाता है।

दोबारा इस्तेमाल: किसी डेटाबेस के लिए एक सर्वर Claude Desktop, Claude Code, एक एडिटर, या किसी कस्टम एजेंट में काम करता है।
मॉडल बदलने की आज़ादी: अपने एप्लिकेशन के पीछे का मॉडल बदलें, तो टूल कनेक्शन काम करते रहते हैं।
अलगाव: हर सर्वर अपने अलग प्रोसेस के रूप में चलता है, इसलिए क्रैश या बग सीमित रहता है।
रनटाइम पर खोज: क्लाइंट कनेक्ट होते समय सर्वरों से पूछते हैं कि वे क्या ऑफ़र करते हैं, इसलिए होस्ट के नए रिलीज़ के बिना नए टूल दिखाई देते हैं।

💡 याद रखने लायक बात: MCP मॉडल को स्मार्ट नहीं बनाता। वह मॉडल को हाथ देता है। सोचने का काम अब भी मॉडल के अंदर होता है, और प्रोटोकॉल केवल अनुरोध बाहर ले जाता है और नतीजे वापस लाता है।

हर सेशन में तीन खिलाड़ी

एक वेटर रेस्टोरेंट की किचन की पास-विंडो से शेफ़ की ओर ऑर्डर की पर्ची सरकाता हुआ

एक रेस्टोरेंट की कल्पना कीजिए। डाइनिंग रूम होस्ट है, वेटर क्लाइंट है, और हर किचन स्टेशन एक सर्वर है। डाइनर कभी चूल्हे से बात नहीं करता, और चूल्हा कभी डाइनर से बात नहीं करता। सब कुछ एक तय हैंड-ऑफ़ के ज़रिए जाता है, और यही काम MCP करता है।

होस्ट

होस्ट वह एप्लिकेशन है जिसे आप असल में खोलते हैं: Claude Desktop, Claude Code, AI फ़ीचर वाला एडिटर, या वह एजेंट जो आपने खुद लिखा है। यह मॉडल के साथ बातचीत का मालिक होता है, सहमति के प्रॉम्प्ट दिखाता है, और तय करता है कि कौन से सर्वर शुरू करने हैं।

क्लाइंट

होस्ट के अंदर, एक क्लाइंट ऑब्जेक्ट एक सर्वर से एक कनेक्शन संभालता है। पाँच सर्वरों से जुड़ें, तो होस्ट के पास पाँच क्लाइंट होते हैं। हर क्लाइंट अपना सेशन स्टेट रखता है, capabilities पर सहमति बनाता है, और होस्ट की आंतरिक कॉल्स और प्रोटोकॉल मैसेज के बीच अनुवाद करता है।

सर्वर

सर्वर एक छोटा प्रोग्राम है जो capabilities उपलब्ध कराता है। यह आपके लैपटॉप पर child process के रूप में चल सकता है, या किसी URL के पीछे दूसरी मशीन पर। एक सर्वर किसी फ़ाइल सिस्टम, GitHub अकाउंट, डेटाबेस, या इमेज जनरेटर को रैप कर सकता है।

भूमिका	कहाँ रहता है	किसकी ज़िम्मेदारी है	उदाहरण
Host	आपका डिवाइस या कोई क्लाउड ऐप	मॉडल के साथ बातचीत, सहमति के प्रॉम्प्ट, सर्वर स्टार्टअप	Claude Desktop, Claude Code
Client	Host के अंदर	हर सर्वर के लिए एक कनेक्शन और एक सेशन	MCP SDK का एक कनेक्शन ऑब्जेक्ट
Server	लोकल प्रोसेस या रिमोट URL	टूल्स, रिसोर्स और प्रॉम्प्ट उपलब्ध कराना	एक फ़ाइल सिस्टम सर्वर, एक डेटाबेस सर्वर

प्रोटोकॉल मैसेज के अंदर

क्लाइंट और सर्वर के बीच हर बातचीत छोटे, सादे और अनुमानित मैसेज की एक धारा होती है। यही पूर्वानुमेयता पूरी बात का मूल है।

नेटवर्क पर JSON-RPC

हर MCP मैसेज JSON-RPC 2.0 है, जो प्रोटोकॉल को ठीक तीन मैसेज शेप देता है:

एक request में एक id और एक method होता है, और यह जवाब की उम्मीद करता है।
एक response वही id दोहराता है और या तो एक result या एक error लेकर आता है।
एक notification में कोई id नहीं होता और यह वापस कुछ नहीं माँगता।

यह एक टूल कॉल है जैसे वह क्लाइंट से सर्वर तक जाती है:

{
  "jsonrpc": "2.0",
  "id": 7,
  "method": "tools/call",
  "params": {
    "name": "generate_image",
    "arguments": { "prompt": "a lighthouse at dawn, 35mm film", "aspect_ratio": "16:9" }
  }
}

और मिलता-जुलता जवाब:

{
  "jsonrpc": "2.0",
  "id": 7,
  "result": {
    "content": [{ "type": "text", "text": "Generation accepted. predict_id: abc123" }],
    "isError": false
  }
}

साझा id ही वह तरीका है जिससे क्लाइंट जवाब को उसके सवाल से मिलाता है, भले ही एक साथ कई कॉल चल रही हों।

हैंडशेक, क्रम से

एक हल्की लकड़ी की मीटिंग टेबल के पार हाथ मिलाते दो लोग

किसी भी टूल के चलने से पहले, क्लाइंट और सर्वर इस पर सहमत होते हैं कि कैसे बात करनी है। क्रम छोटा है और हमेशा एक जैसा रहता है:

initialize (request): क्लाइंट वह प्रोटोकॉल वर्ज़न भेजता है जो वह चाहता है, वे capabilities जिन्हें वह सपोर्ट करता है, और अपना नाम व वर्ज़न।
initialize (response): सर्वर उस वर्ज़न के साथ जवाब देता है जिसका वह इस्तेमाल करेगा, अपनी capabilities, और मॉडल के लिए वैकल्पिक लिखित निर्देश।
notifications/initialized: क्लाइंट पुष्टि करता है, और सेशन खुल जाता है।
tools/list, resources/list, prompts/list: क्लाइंट पूछता है कि सर्वर क्या ऑफ़र करता है, उन्हीं capabilities तक सीमित, जिन्हें दोनों पक्षों ने घोषित किया है।
सामान्य ट्रैफ़िक: कॉल्स, रीड्स, और कभी-कभार notifications/tools/list_changed जब कोई सर्वर सेशन के बीच में टूल जोड़ता या हटाता है।

💡 वर्ज़न मेल नहीं खाता: अगर सर्वर उस वर्ज़न को सपोर्ट नहीं करता जो क्लाइंट ने माँगा, तो वह एक ऐसा वर्ज़न लौटाता है जिसे वह सपोर्ट करता है। क्लाइंट या तो वह वर्ज़न स्वीकार करता है या साफ़ तरीके से डिस्कनेक्ट हो जाता है।

stdio बनाम Streamable HTTP

शांत डेटा सेंटर के गलियारे में सर्वर रैक के बीच नीचे से देखा गया दृश्य

वही JSON-RPC मैसेज दो आधिकारिक transports पर चल सकते हैं।

stdio में होस्ट सर्वर को एक चाइल्ड प्रोसेस के रूप में चलाता है और स्टैंडर्ड इनपुट व आउटपुट के ज़रिए न्यूलाइन से अलग किया गया JSON भेजता-पाता है। लॉग स्टैंडर्ड एरर पर ही जाने चाहिए, क्योंकि स्टैंडर्ड आउटपुट पर एक भी बेवजह का प्रिंट पूरी स्ट्रीम को बिगाड़ देता है। Streamable HTTP में सर्वर एक ही URL के पीछे रहता है, क्लाइंट POST रिक्वेस्ट से मैसेज भेजता है, और सर्वर सादे JSON से जवाब देता है। जब उसे कई मैसेज वापस भेजने होते हैं, तो वह स्ट्रीमिंग रिस्पॉन्स खोल देता है। स्पेसिफिकेशन के मार्च 2025 वाले संशोधन में Streamable HTTP ने पुराने HTTP plus SSE ट्रांसपोर्ट की जगह ले ली।

विशेषता	stdio	Streamable HTTP
सर्वर कहाँ चलता है	आपकी मशीन पर, एक child process के रूप में	URL से कहीं भी पहुँचा जा सकने वाला स्थान
सेटअप	कॉन्फ़िग फ़ाइल में एक कमांड	एक डिप्लॉय किया हुआ endpoint
प्रमाणीकरण	आपके यूज़र की अनुमतियाँ विरासत में मिलती हैं	OAuth आधारित authorization
आम यूज़र	अकेले डेवलपर, लोकल टूल	टीम, होस्टेड सेवाएँ, साझा कनेक्टर
एक साथ जुड़े क्लाइंट	एक	कई

स्थानीय सर्वर के लिए एक विशिष्ट Claude Desktop entry कुछ ऐसी दिखती है:

{
  "mcpServers": {
    "files": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/projects"]
    }
  }
}

टूल्स, रिसोर्सेज़ और प्रॉम्प्ट्स

वर्कशॉप की पेगबोर्ड दीवार, जिस पर हथौड़े, पाना और प्लायर पेंट की रूपरेखा में टँगे हुए हैं

सर्वर तीन बिल्डिंग ब्लॉक उपलब्ध कराते हैं। वे मुख्य रूप से इस बात में अलग हैं कि उन्हें कब इस्तेमाल करना है यह कौन तय करता है।

प्रिमिटिव	नियंत्रित कौन करता है	उद्देश्य	उदाहरण	मेथड्स
टूल्स	मॉडल	कोई क्रिया करना या कंप्यूटेशन चलाना	`generate_image`, `run_query`	`tools/list`, `tools/call`
रिसोर्सेज़	एप्लिकेशन	केवल-पढ़ने योग्य संदर्भ देना	एक फ़ाइल, एक डेटाबेस स्कीमा	`resources/list`, `resources/read`
प्रॉम्प्ट्स	उपयोगकर्ता	दोबारा इस्तेमाल होने वाले टेम्पलेट देना	एक "इस pull request की समीक्षा करें" कमांड	`prompts/list`, `prompts/get`

टूल्स काम करते हैं

एक टूल का name, एक description, और JSON Schema में लिखी एक inputSchema होती है। विवरण वह है जो मॉडल असल में पढ़ता है यह तय करने के लिए कि टूल कॉल करना है या नहीं, इसलिए धुंधला विवरण गलत या छूटी हुई कॉल्स पैदा करता है। इसे किसी ऐसे सहकर्मी के लिए एक छोटे मैनुअल की तरह लिखें जिसने आपका सिस्टम कभी नहीं देखा।

असली कनेक्टर यह पैटर्न अच्छी तरह दिखाते हैं। claude.ai PicassoIA कनेक्टर generate_image, edit_image, generate_video_picassoia, generate_video_seedance, get_generation, और list_models जैसे टूल्स उपलब्ध कराता है। एक जनरेशन टूल तुरंत एक prediction id लौटाता है, और फिर मॉडल get_generation को बार-बार कॉल करता है जब तक status succeeded न दिखाए। यह एक उपयोगकर्ता अनुरोध का एक के बाद एक जुड़ी कई टूल कॉल्स में बदल जाना है, और इसके लिए प्रोटोकॉल को कभी कोई खास फ़ीचर नहीं चाहिए था।

रिसोर्सेज़ संदर्भ देते हैं

रिसोर्सेज़ URI से पहचाने जाते हैं, जैसे file:///project/README.md। होस्ट तय करता है कि कौन से रिसोर्सेज़ बातचीत में जोड़े जाएँ, और resources/read MIME type के साथ सामग्री लौटाता है। सर्वर पैरामीटर वाले resource templates भी प्रकाशित कर सकते हैं, और क्लाइंट बदलावों की सदस्यता ले सकते हैं ताकि संदर्भ ताज़ा बना रहे।

प्रॉम्प्ट्स वर्कफ़्लो पैक करते हैं

प्रॉम्प्ट्स वे टेम्पलेट हैं जिन्हें उपयोगकर्ता जानबूझकर ट्रिगर करता है, आमतौर पर slash commands के रूप में। एक प्रॉम्प्ट आर्गुमेंट ले सकता है और तैयार मैसेज का सेट लौटा सकता है, इसलिए एक टीम अपना सबसे अच्छा "इस incident का सारांश दें" या "release notes लिखें" वाला वाक्य एक बार शिप कर सकती है और हर जगह दोबारा इस्तेमाल कर सकती है।

जब Claude टूल कॉल करता है तो क्या होता है

एक इंजीनियर बड़े व्हाइटबोर्ड पर घुमावदार तीरों से जुड़े तीन बॉक्स बनाते हुए

लोग जो बात सबसे ज़्यादा गलत समझते हैं वह यह है: मॉडल कभी MCP नहीं बोलता। होस्ट बोलता है। Claude केवल अपने tool-use फ़ॉर्मेट में टूल डेफ़िनिशन देखता है और संरचित अनुरोध भेजता है। बाकी सब प्लंबिंग है।

सवाल से टूल कॉल तक

आप पूछते हैं। "हीरो फ़ोटो को रीसाइज़ करें और मेरे प्रोजेक्ट फ़ोल्डर में सेव कर दें।"
Host कॉन्टेक्स्ट भेजता है। वह आपका मैसेज और हर कनेक्टेड सर्वर से इकट्ठा की गई टूल परिभाषाएँ मॉडल API को भेजता है।
Claude तय करता है। अंतिम टेक्स्ट देने के बजाय वह एक tool_use ब्लॉक लौटाता है, जिसमें टूल का नाम और उसके आर्ग्युमेंट होते हैं।
Host सहमति जाँचता है। वह एक अनुमति प्रॉम्प्ट दिखा सकता है, फिर कॉल को उस क्लाइंट तक पहुँचाता है जिसके पास वह टूल है।
Client सर्वर को कॉल करता है। एक tools/call रिक्वेस्ट जाती है, सर्वर काम करता है और content ब्लॉक लौटाता है।
Host नतीजा बताता है। नतीजा अब तक की बातचीत के साथ एक tool_result ब्लॉक के रूप में Claude को जाता है।
Claude आगे बढ़ता है। वह कोई दूसरा टूल कॉल करता है या अंतिम जवाब लिखता है।

एजेंट लूप कहाँ रहता है

चरण 3 से 7 तब तक दोहराए जाते हैं जब तक Claude टूल्स माँगना बंद न कर दे। यह दोहराव एजेंट लूप है, और यह प्रोटोकॉल में नहीं, होस्ट में रहता है। MCP दरवाज़े तय करता है। होस्ट तय करता है कि उनसे कितनी बार गुज़रना है। AI एजेंट बस एक ऐसा होस्ट है जो इसी लूप को लंबी योजनाओं और कम रुकावटों के साथ चलाता है, और कभी-कभी अपने सहायक एजेंट भी रखता है।

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

सुरक्षा और अनुमतियाँ

एक पुराने लकड़ी के गेट पर गैल्वनाइज़्ड चेन से लटका भारी पीतल का ताला

जो सर्वर कमांड चला सकता है या फ़ाइलों को छू सकता है, वह शक्तिशाली है, और इसीलिए उसे guardrails की ज़रूरत है।

सहमति सबसे पहले

स्पेसिफ़िकेशन के अनुसार होस्ट को टूल चलाने या डेटा साझा करने से पहले यूज़र की स्पष्ट सहमति लेनी चाहिए, और परिपक्व होस्ट अनुमति प्रॉम्प्ट और हर टूल के लिए अलग allow list के साथ इसका पालन करते हैं। याद रखें कि लोकल stdio सर्वर आपकी यूज़र अनुमतियों के साथ चलता है, इसलिए उसे इंस्टॉल करना वैसे ही लें जैसे आप कोई भी प्रोग्राम इंस्टॉल करते हैं। रिमोट सर्वर OAuth जोड़ते हैं, जिससे आप सीमित एक्सेस दे सकते हैं और बाद में उसे रद्द कर सकते हैं।

आम विफलता बिंदु

नतीजों के ज़रिए prompt injection: किसी टूल द्वारा लौटाया गया वेब पेज, टिकट या ईमेल ऐसा टेक्स्ट रख सकता है जो मॉडल को नए आदेश देने की कोशिश करे।
दूषित टूल डिस्क्रिप्शन: एक दुर्भावनापूर्ण सर्वर अपने ही विवरणों में निर्देश छिपा सकता है।
ज़रूरत से ज़्यादा व्यापक credentials: एक token जो सब कुछ मिटा सकता है, आख़िरकार सब कुछ मिटाने के लिए इस्तेमाल होगा। केवल-पढ़ने वाली access को प्राथमिकता दें।
शोर वाला standard output: stdio सर्वर में debugging prints JSON धारा को तोड़ देते हैं।
बहुत ज़्यादा टूल्स: दर्जनों उपलब्ध होने पर मॉडल गलत टूल ज़्यादा बार चुनता है। हर सर्वर को केंद्रित रखें।
लंबे काम: एक कॉल जो दस मिनट चलती है, timeout हो जाती है। एक id लौटाएँ और मॉडल को poll करने दें, जैसे इमेज और वीडियो जनरेटर करते हैं।

PicassoIA पर Claude Sonnet 5 इस्तेमाल करें

अगर आप अपना खुद का सर्वर बनाना चाहते हैं, तो PicassoIA पर Claude Sonnet 5 एक काम का pair programmer है। यह मल्टी-स्टेप कोडिंग और टूल-यूज़ के कामों के लिए बना है, और यह इमेज भी पढ़ता है, इसलिए किसी error का screenshot इनपुट के रूप में काम करता है।

मॉडल पेज खोलें। large language models कलेक्शन में Claude Sonnet 5 पेज पर जाएँ।
प्रॉम्प्ट लिखें। यही एकमात्र ज़रूरी फ़ील्ड है। भाषा, SDK और जिस टूल की आपको ज़रूरत है, उसके बारे में साफ़-साफ़ बताएँ।
effort सेट करें। डिफ़ॉल्ट low है, जो तेज़ जवाबों के लिए एक्सटेंडेड थिंकिंग छोड़ देता है। कई फ़ाइलों में फैले बग के लिए इसे बढ़ाएँ।
सीमाएँ समायोजित करें। max_tokens का डिफ़ॉल्ट 8192 है, और एक वैकल्पिक system_prompt किसी role या coding style को सेशन के लिए पक्का कर देता है।
ज़रूरत हो तो इमेज जोड़ें। image फ़ील्ड एक screenshot स्वीकार करता है, और max_image_resolution (डिफ़ॉल्ट 0.5 megapixels) उसे हल्का रखता है।
जनरेट करें और समीक्षा करें। कोड अपने प्रोजेक्ट में कॉपी करें और उस पर भरोसा करने से पहले MCP Inspector से टेस्ट करें।

एक प्रॉम्प्ट जो अच्छा काम करता है:

Write a minimal MCP server in TypeScript using the official SDK. It exposes one tool,
word_count, that takes a string and returns the number of words. Use the stdio transport
and log only to stderr. Include the claude_desktop_config.json entry to register it.

PicassoIA खुद भी MCP बोलता है। इसका claude.ai कनेक्टर चार मॉडल सूचीबद्ध करता है: PicassoIA Image, PicassoIA Image Editor Pro, PicassoIA Video, और Seedance 2.5 Lite, जो ऑडियो के साथ वीडियो बनाता है। Predictions असिंक्रोनस होते हैं, और एक अकाउंट अपने सभी कनेक्शनों में मिलाकर एक समय पर पाँच चला सकता है, इसलिए हर बैच छोटा रखें। आपके प्लान में क्या शामिल है, यह जानने के लिए pricing पेज देखें।

आज ही अपने विज़ुअल्स बनाएँ

लंबी लकड़ी की मेज़ पर बैठा एक डिज़ाइनर गोल्डन आवर की रोशनी में लैंडस्केप फ़ोटो एडिट करते हुए

हर सहज "Claude, मेरे लिए एक इमेज बनाएँ" वाले पल के पीछे एक हैंडशेक, एक स्कीमा और एक लूप होता है। इसे महसूस करने का सबसे तेज़ तरीका है कुछ बनाना। PicassoIA Image खोलें और एक दृश्य का वर्णन करें, फिर एक अलग लुक के लिए Seedream 4.5 या FLUX 2 Pro पर स्विच करें, और फिर नतीजा Seedance 2.0 को दें ताकि एक स्थिर चित्र को छोटी क्लिप में बदला जा सके। PicassoIA कनेक्टर को Claude से जोड़ें, और आप यह सब सादी भाषा में माँग सकते हैं, फिर इस आर्टिकल की टूल कॉल्स को रीयल टाइम में चलते देख सकते हैं।

ऊपर के सेक्शनों में से एक विचार चुनें, वह एक वाक्य लिखें कि आप क्या देखना चाहते हैं, और उसे चलाएँ। आपकी पहली इमेज picassoia.com पर बस कुछ सेकंड दूर है।

यह लेख शेयर करें

अपनी भाषा चुनें