OpenAI Responses API: डेवलपर्स के लिए अंतिम मार्गदर्शिका

OpenAI की Responses API क्या है?

Responses API, OpenAI की सबसे नई और उन्नत API है। यह Chat Completions और Assistants APIs की ताकतों को एक एकीकृत, सरल इंटरफ़ेस में जोड़ती है। मार्च 2025 में जारी, यह परिचित क्षमताओं को बनाए रखते हुए AI एप्लिकेशन बनाने का अधिक एकीकृत तरीका प्रदान करती है। 

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

इस ट्यूटोरियल में, हम देखेंगे कि आप अपने प्रोजेक्ट्स में Responses API का उपयोग कैसे कर सकते हैं। आप जानेंगे कि यह टेक्स्ट जनरेशन कैसे संभालती है, इमेजेस के साथ कैसे काम करती है, और स्ट्रीमिंग रिस्पॉन्स कैसे देती है। हम बिल्ट-इन टूल्स का भी परीक्षण करेंगे जो विकास को पहले की तुलना में तेज़ और सरल बनाते हैं, और दिखाएंगे कि ये टूल्स API के फ्रेमवर्क के भीतर एक-दूसरे के साथ कैसे काम करते हैं। 

इस गाइड के अंत तक, आप समझ जाएंगे कि अन्य OpenAI विकल्पों की बजाय कब Responses API का उपयोग करना चाहिए और यह समझ आपको कम कोड और कम प्रयास में अधिक कुशल एप्लिकेशन बनाने में कैसे मदद कर सकती है। यदि आप OpenAI API में नए हैं, तो हमारी प्रारंभिक कोर्स Working with the OpenAI API देखें और AI-संचालित एप्लिकेशन विकसित करने की यात्रा शुरू करें।

Responses API के साथ शुरुआत

Responses API, OpenAI के मॉडलों के साथ इंटरैक्ट करने के लिए एक अधिक सुव्यवस्थित और उपयोगकर्ता-अनुकूल इंटरफ़ेस प्रदान करती है, जो पहले विस्तृत और जटिल सिंटैक्स की मांग करता था—इसे अब एक सुरुचिपूर्ण समाधान में समेटती है। 

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

from openai import OpenAI
import os
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# Initialize the client
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))संचालित द्वारा

यह प्रारंभिक चरण एक क्लाइंट ऑब्जेक्ट बनाता है जो आपकी सभी API रिक्वेस्ट्स को संभालेगा। dotenv पैकेज आपकी API कुंजी को स्क्रिप्ट में हार्डकोड करने के बजाय वातावरण चर के माध्यम से सुरक्षित रूप से प्रबंधित करने में मदद करता है—यह एक सर्वोत्तम प्रथा है जो अलग-अलग वातावरणों में आपके कोड को अधिक पोर्टेबल और सुरक्षित बनाती है।

Responses API से सामग्री जनरेट करना

Responses API का सबसे सरल उपयोग है टेक्स्ट सामग्री बनाना। एक वास्तविक परिदृश्य देखें: मान लें कि आप एक ई-कॉमर्स प्लेटफ़ॉर्म बना रहे हैं और आपको बुनियादी उत्पाद विवरणों के आधार पर स्वतः आकर्षक उत्पाद वर्णन तैयार करने की आवश्यकता है।

परंपरागत रूप से, इसके लिए सावधानीपूर्वक प्रॉम्प्ट इंजीनियरिंग और कई इटरशन की आवश्यकता होती। Responses API के साथ, आप एक सरल फ़ंक्शन बना सकते हैं जो इसे सहजता से संभालता है:

def generate_product_description(product_name, features, target_audience):
   response = client.responses.create(
       model="gpt-4o",
       instructions="You are a professional copywriter specialized in creating concise, compelling product descriptions. Focus on benefits rather than just features.",
       input=f"""
       Create a product description for {product_name}.
       Key features:
       - {features[0]}
       - {features[1]}
       - {features[2]}
       Target audience: {target_audience}
       Keep it under 150 words.
       """,
       temperature=0.7,
       max_output_tokens=200
   )
  
   return response.output_text

# Example usage
headphones_desc = generate_product_description(
   "NoiseGuard Pro Headphones",
   ["Active noise cancellation", "40-hour battery life", "Memory foam ear cushions"],
   "Business travelers and remote workers"
)

print(headphones_desc)संचालित द्वारा

आउटपुट:

Experience unparalleled focus and comfort with NoiseGuard Pro Headphones—your perfect travel and work companion. 
Designed for business travelers and remote workers, these headphones feature cutting-edge active noise cancellation to block out distractions, allowing you to concentrate on what truly matters. 
With an impressive 40-hour battery life, you can enjoy uninterrupted productivity or relaxation on even the longest journeys. 
The luxurious memory foam ear cushions ensure a snug, comfortable fit for all-day wear, reducing fatigue and enhancing your listening experience. 
Elevate your work and travel with NoiseGuard Pro—where clarity meets comfort.संचालित द्वारा

कुछ ही पंक्तियों के कोड से, हमने ऐसा मार्केटिंग-गुणवत्ता वाला कॉपी तैयार किया है जिसके लिए आमतौर पर एक प्रोफ़ेशनल लेखक की ज़रूरत पड़ती। यह फ़ंक्शन पुन: प्रयोज्य भी है—बस पैरामीटर बदलें और आप अपने कैटलॉग के किसी भी उत्पाद के लिए वर्णन बना सकते हैं।

यह उदाहरण Responses API का उपयोग करते समय प्रमुख पैटर्न दर्शाता है:

1. instructions पैरामीटर एक सिस्टम प्रॉम्प्ट की तरह कार्य करता है, AI के व्यवहार और संदर्भ को परिभाषित करता है।
2. temperature पैरामीटर (0-2) रैंडमनेस को नियंत्रित करता है—कम मान अधिक निर्धारक आउटपुट देते हैं, जबकि अधिक मान रचनात्मकता बढ़ाते हैं।
3. max_output_tokens प्रतिक्रिया की लंबाई सीमित करता है, जिससे लागत नियंत्रित रहती है और आउटपुट संक्षिप्त रहता है।
4. रिस्पॉन्स ऑब्जेक्ट में जनरेट किया गया टेक्स्ट output_text प्रॉपर्टी में होता है।

व्यावहारिक उपयोगों के लिए इमेजेस का विश्लेषण

कई वास्तविक-world एप्लिकेशनों को टेक्स्ट और इमेज—दोनों को संसाधित करने की ज़रूरत होती है। उदाहरण के लिए, ई-कॉमर्स प्लेटफ़ॉर्म को उत्पाद फ़ोटो का विश्लेषण करना होता है, कंटेंट मॉडरेशन सिस्टम को अपलोड की समीक्षा करनी होती है, और सोशल मीडिया ऐप्स को विज़ुअल कंटेंट समझना होता है।

Responses API, इमेज विश्लेषण जैसे मल्टीमॉडल कार्यों में उत्कृष्ट है—इसके लिए अलग एंडपॉइंट्स या जटिल इंटीग्रेशन कोड की ज़रूरत नहीं होती:

def analyze_product_image(image_url):
   response = client.responses.create(
       model="gpt-4o",
       instructions="You are a product photography expert and e-commerce consultant.",
       input=[
           {"role": "user", "content": "Analyze this product image and provide the following details:\n1. Product category\n2. Key visible features\n3. Potential quality issues\n4. Suggested improvements for the product photography"},
           {
               "role": "user",
               "content": [
                   {
                       "type": "input_image",
                       "image_url": image_url
                   }
               ],
           },
       ],
       temperature=0.2
   )
  
   return response.output_text

# Example with a sports team image
analysis = analyze_product_image("https://upload.wikimedia.org/wikipedia/commons/a/a5/Barcelona_fc_lamina_elgrafico.jpg")
print(analysis)संचालित द्वारा

आउटपुट:

1. **Product Category**: Sports team memorabilia or vintage sports photography.

2. **Key Visible Features**:
  - The image features a group of individuals in sports uniforms, likely a football (soccer) team.
  - The uniforms have distinct vertical stripes in red and blue.
  - A football is visible in the foreground.
  - The setting appears to be an outdoor field, possibly a stadium.

...संचालित द्वारा

यह फ़ंक्शन एक ई-कॉमर्स प्लेटफ़ॉर्म में एकीकृत किया जा सकता है ताकि व्यापारी जब उत्पाद फ़ोटो अपलोड करें तो उनका स्वतः विश्लेषण हो जाए। सिस्टम तुरंत इमेज गुणवत्ता पर फीडबैक दे सकता है और सुधार सुझा सकता है, जिससे उच्च-गुणवत्ता वाली लिस्टिंग के जरिए बेहतर कन्वर्ज़न दरें हासिल हों—वह भी बिना मैनुअल समीक्षा के।

इमेज के साथ काम करते समय, आपको स्ट्रिंग के बजाय इनपुट पैरामीटर में मैसेज ऑब्जेक्ट्स का एक एरे पास करना चाहिए, जिनमें प्रत्येक में role और content वैल्यू होती हैं।

 इमेज कंटेंट को type: input_image और image_url वाले ऑब्जेक्ट के रूप में निर्दिष्ट किया जाता है। आप एक ही रिक्वेस्ट में टेक्स्ट और इमेजेस को संयोजित कर सकते हैं, जिससे समृद्ध मल्टीमॉडल इंटरैक्शन संभव होता है।

उत्तरदायी एप्लिकेशन हेतु स्ट्रीमिंग लागू करना

उपयोगकर्ता त्वरित प्रतिक्रिया की अपेक्षा करते हैं। AI प्रतिक्रिया के लिए कई सेकंड इंतजार कराना एंगेजमेंट को घटा सकता है—इसीलिए स्ट्रीमिंग विशेषकर चैट या रीयल-टाइम एप्लिकेशनों में उत्तरदायी अनुभव बनाने के लिए आवश्यक है।

कल्पना करें कि आप किसी प्रोडक्ट टीम के लिए कस्टमर फीडबैक विश्लेषण टूल बना रहे हैं। पूर्ण विश्लेषण का इंतजार कराने के बजाय, आप परिणामों को जनरेट होते ही स्ट्रीम कर सकते हैं:

def analyze_customer_feedback(feedback_text):
   print("Analyzing customer feedback in real-time:")
  
   stream = client.responses.create(
       model="gpt-4o",
       instructions="Extract key sentiments, product issues, and actionable insights from this feedback.",
       input=feedback_text,
       stream=True,
       temperature=0.3,
       max_output_tokens=500
   )
  
   full_response = ""
   print("\nAnalysis results:")
   for event in stream:
       if event.type == "response.output_text.delta":
           print(event.delta, end="")
           full_response += event.delta
       elif event.type == "response.error":
           print(f"\nError occurred: {event.error}")
  
   return full_response

# Example with a complex customer review
feedback = """
I've been using the SmartHome Hub for about 3 months now. The voice recognition is fantastic
and the integration with my existing devices was mostly seamless. However, the app crashes
at least once a day, and the night mode feature often gets stuck until I restart the system.
Customer support was helpful but couldn't fully resolve the app stability issues.
"""

analysis_result = analyze_customer_feedback(feedback)संचालित द्वारा

एक वास्तविक एप्लिकेशन में, आप print स्टेटमेंट्स को UI अपडेट्स से बदलेंगे, जिससे आपके उपयोगकर्ता विश्लेषण को रीयल-टाइम में बनते हुए देख सकें—ठीक वैसे ही जैसे आधुनिक चैट एप्लिकेशन AI को प्रतिक्रिया जनरेट करते समय “सोचता हुआ” दिखाते हैं। यह अधिक आकर्षक अनुभव बनाता है और उपयोगकर्ताओं को तुरंत फीडबैक देता है कि उनकी रिक्वेस्ट प्रोसेस हो रही है।

स्ट्रीमिंग इम्प्लीमेंटेशन इस तरह काम करती है:

1. create मेथड में stream=True सेट करना
2. रिस्पॉन्स को विशिष्ट प्रकार की घटनाओं (events) के एक iterable के रूप में प्रोसेस करना
3. अलग-अलग event प्रकारों को अलग से हैंडल करना: कंटेंट चंक्स के लिए response.output_text.delta, त्रुटियों के लिए response.error

अब जब हमने Responses API की बुनियादी कार्यक्षमता कवर कर ली है, तो आइए इसके बिल्ट-इन टूल्स का पता लगाएं जो इसकी क्षमताओं को और बढ़ाते हैं।

OpenAI Responses API के बिल्ट-इन टूल्स

Responses API कुछ बिल्ट-इन टूल्स को इंटीग्रेट करती है जो इसकी क्षमताओं को बुनियादी टेक्स्ट जनरेशन से आगे बढ़ाते हैं। ये टूल्स डेवलपर्स को जटिल इंटीग्रेशन कोड या कई API कॉल्स की आवश्यकता के बिना अधिक शक्तिशाली एप्लिकेशन बनाने देते हैं।

वेब सर्च: रीयल-टाइम जानकारी तक पहुंच

वेब सर्च टूल, Responses API को इंटरनेट से ताज़ा जानकारी प्राप्त करने में सक्षम बनाता है, जो LLMs के केवल प्रशिक्षण डाटा तक सीमित होने की सीमा को संबोधित करता है।

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
   model="gpt-4o",
   tools=[{"type": "web_search_preview"}],
   input="What are some news related to the stock market?",
)

print(response.output_text)संचालित द्वारा

आउटपुट:

Recent developments in the stock market have been significantly influenced by escalating trade tensions between the United States and China. On April 5, 2025, President Donald Trump announced an additional 34% tariff on Chinese goods, raising total tariffs to 54% this year. In response, China imposed reciprocal 34% tariffs on U.S. products and introduced export restrictions on certain rare earth elements. These actions led to a sharp global market selloff, with the S&P 500 falling 9% for the week, marking the steepest decline since the pandemic. (reuters.com)

…..


## Escalating US-China Trade Tensions Impact Global Markets:
- [China says 'market has spoken' after US tariffs spark selloff](https://www.reuters.com/world/china/china-says-market-has-spoken-after-us-tariffs-spark-selloff-2025-04-05/?utm_source=openai)
- [Trump touts "economic revolution" as economists warn of recession](https://www.axios.com/2025/04/05/trump-tariffs-stock-market-recession?utm_source=openai)
- [Believe it or not, there were some winners in the stock market this week](https://apnews.com/article/ce81e9ae6fb463dc763dfaa464778343?utm_source=openai)संचालित द्वारा

वेब सर्च टूल सक्रिय होने पर कई ऑपरेशंस करता है—क्वेरी का विश्लेषण करने से लेकर कई स्रोतों से जानकारी संकलित करने तक, वह भी उचित संदर्भ (citations) के साथ। यह क्षमता सूचना-संपन्न एप्लिकेशनों, जैसे बाजार अंतर्दृष्टि देने वाले वित्तीय विश्लेषण टूल्स, कई स्रोतों को जोड़ने वाले न्यूज़ एग्रीगेशन प्लेटफ़ॉर्म, या ताज़ा शोध से मुख्य सामग्री को पूरक करने वाले शैक्षिक संसाधनों के लिए उपयोगी है।

इस टूल का एक मुख्य लाभ यह है कि समयानुकूल जानकारी प्रदान करने के लिए आपको कस्टम सर्च इंटीग्रेशन या वेब स्क्रैपिंग सिस्टम बनाने और बनाए रखने की आवश्यकता नहीं होती। टूल खुद सर्च प्रक्रिया को संभालता है और स्रोतों के बारे में पारदर्शिता बनाए रखने हेतु उचित सिटेशंस के साथ परिणाम प्रस्तुत करता है।

फ़ाइल सर्च: दस्तावेज़ों से जानकारी निकालना

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

फ़ाइल सर्च टूल कई प्रमुख क्षमताएं सक्षम करता है:

• एकाधिक फ़ाइल प्रकारों (PDF, Word दस्तावेज़, प्रेजेंटेशन आदि) में खोज करना।
• नेचुरल लैंग्वेज क्वेरी के आधार पर दस्तावेज़ों के भीतर विशिष्ट जानकारी खोजना।
• एक साथ कई दस्तावेज़ों से जानकारी निकालना और संश्लेषित करना।
• स्रोत दस्तावेज़ों के विशिष्ट अनुभागों के संदर्भ (citations) प्रदान करना।
• ऐसी जटिल क्वेरीज को सपोर्ट करना जो कई फ़ाइलों में फैली जानकारी का संदर्भ दें।

यह क्षमता दस्तावेज़ विश्लेषण उपयोग मामलों—जैसे कानूनी अनुबंधों से जानकारी निकालना, शोध पत्रों का विश्लेषण, या तकनीकी दस्तावेज़ों से नॉलेज बेस बनाना—के लिए उपयुक्त है। यह टूल कई दस्तावेज़ों में प्रासंगिक अनुभागों की पहचान कर सकता है और विशिष्ट क्वेरीज के जवाब में जानकारी का संश्लेषण कर सकता है।

इम्प्लीमेंटेशन के लिए पहले फाइलों को OpenAI के फाइल एंडपॉइंट पर अपलोड करना पड़ता है, फिर क्वेरी करते समय उन फ़ाइल IDs को Responses API में पास करना होता है। इससे उन एप्लिकेशनों के लिए एक सुव्यवस्थित वर्कफ़्लो बनता है जिन्हें दस्तावेज़ों के भीतर विशिष्ट जानकारी का संदर्भ देना होता है—बिना उपयोगकर्ताओं से मैन्युअल रूप से खोज कराए।

कंप्यूटर यूज़: इंटरफ़ेस इंटरेक्शन क्षमताएं

टेक्स्ट और दस्तावेज़ समझ की नींव पर, कंप्यूटर यूज़ टूल AI क्षमताओं को इंटरफ़ेस इंटरेक्शन के क्षेत्र में विस्तारित करता है। यह टूल भाषा समझ और यूज़र इंटरफ़ेस मैनिपुलेशन के बीच की खाई को पाटने वाला एक महत्वपूर्ण कदम है।

कंप्यूटर यूज़ टूल विभिन्न प्रकार के इंटरफ़ेस इंटरेक्शन कर सकता है:

• वेबसाइट्स और वेब एप्लिकेशनों में स्वायत्त नेविगेशन।
• उचित जानकारी के साथ फ़ॉर्म्स भरना।
• वेब पेजों और एप्लिकेशनों से डेटा निकालना।
• विभिन्न स्क्रीन पर मल्टी-स्टेप प्रक्रियाओं को निष्पादित करना।
• बटन, ड्रॉपडाउन और टेक्स्ट फ़ील्ड जैसे एलिमेंट्स के साथ इंटरेक्ट करना।
• विभिन्न इंटरफ़ेस एलिमेंट्स के संदर्भ और उद्देश्य को समझना।

संभावित उपयोगों में दोहराव वाले कार्यों के लिए प्रोसेस ऑटोमेशन, जटिल वर्कफ़्लोज़ के लिए गाइडेड असिस्टेंस, और उन उपयोगकर्ताओं के लिए एक्सेसिबिलिटी सुधार शामिल हैं जिन्हें पारंपरिक इंटरफ़ेस में कठिनाई होती है। यह टूल फ़ॉर्म भरने का ऑटोमेशन, जटिल वेबसाइटों में नेविगेशन, या यूज़र इंटरफ़ेस के परीक्षण में उपयोग हो सकता है।

यह तकनीक AI को स्क्रीन एलिमेंट्स देखने और उनके साथ इंटरेक्ट करने, संदर्भ समझने, और नेचुरल लैंग्वेज निर्देशों के आधार पर क्रियाएं निष्पादित करने देती है। इससे ऐसे ऑटोमेशन और असिस्टेंस की संभावनाएं बनती हैं जिनके लिए अन्यथा इंटरफ़ेस-विशिष्ट कोड का विशेष विकास करना पड़ता।

अतिरिक्त टूल क्षमताएं

Responses API के भीतर टूल्स का इकोसिस्टम बढ़ता जा रहा है, और OpenAI नियमित रूप से नई क्षमताएं जोड़ रहा है। व्यापक टूल्स दस्तावेज़ वर्तमान में उपलब्ध सभी टूल्स के इम्प्लीमेंटेशन विवरण कवर करता है, जबकि एजेंट्स बनाने के नए टूल्स पर लेख यह बताता है कि ये टूल्स रणनीतिक रूप से कैसे विकसित हो रहे हैं।

ये बिल्ट-इन टूल्स बॉक्स से बाहर ही शक्तिशाली क्षमताएं प्रदान करते हैं, लेकिन कई एप्लिकेशनों को विशेष सेवाओं या मालिकाना सिस्टम्स से कनेक्ट करने की आवश्यकता होती है। यहीं पर फ़ंक्शन कॉलिंग आवश्यक हो जाती है—यह आपको अपने कस्टम टूल्स और बाहरी सेवाओं के साथ Responses API का विस्तार करने देती है—जो हमारी अगली धारा का केंद्र है।

Responses API में फ़ंक्शन कॉलिंग

हालांकि बिल्ट-इन टूल्स शक्तिशाली क्षमताएं देते हैं, कई एप्लिकेशनों को विशेष सेवाओं या मालिकाना सिस्टम्स से कनेक्ट होना पड़ता है। फ़ंक्शन कॉलिंग आपको अपने कस्टम टूल्स के साथ Responses API का विस्तार करने देती है, जिससे मॉडल उपयोगकर्ता इनपुट के आधार पर यह तय कर सके कि आपके फ़ंक्शंस कब और कैसे कॉल करने हैं।

फ़ंक्शन कॉलिंग, AI की भाषा समझ और आपके बाहरी सिस्टम्स—चाहे वह विनिमय दरें लाना हो, दूरी की गणना करना हो, या अपॉइंटमेंट उपलब्धता जांचना हो—के बीच एक पुल बनाती है। यह पैटर्न एक स्पष्ट वर्कफ़्लो का अनुसरण करता है:

1. आप वे फ़ंक्शंस परिभाषित करते हैं जिन्हें AI उपयोग कर सकता है, उनके पैरामीटर्स और प्रकार निर्दिष्ट करते हैं।
2. AI उपयोगकर्ता क्वेरीज के आधार पर तय करता है कि कब इन फ़ंक्शंस को कॉल करना है।
3. आपका कोड, AI द्वारा दिए गए पैरामीटर्स के साथ फ़ंक्शंस चलाता है।
4. आप परिणामों को AI को लौटाते हैं, जो उन्हें अपनी प्रतिक्रिया में शामिल करता है।

एक करेंसी कन्वर्ज़न टूल बनाना

आइए एक सरल करेंसी कन्वर्ज़न फ़ंक्शन को उदाहरण के तौर पर इम्प्लीमेंट करें:

# Dictionary of exchange rates (relative to USD)
exchange_rates = {
   "USD": 1.0,
   "EUR": 0.93,
   "GBP": 0.79,
   "JPY": 153.2,
   "CAD": 1.37,
   "AUD": 1.52
}

def convert_currency(amount, from_currency, to_currency):
   """Convert an amount from one currency to another."""
   # Normalize currency codes to uppercase
   from_currency = from_currency.upper()
   to_currency = to_currency.upper()
  
   # Check if currencies are supported
   if from_currency not in exchange_rates:
       return {"error": f"Currency not supported: {from_currency}"}
   if to_currency not in exchange_rates:
       return {"error": f"Currency not supported: {to_currency}"}
  
   # Convert to USD first, then to target currency
   amount_in_usd = amount / exchange_rates[from_currency]
   converted_amount = amount_in_usd * exchange_rates[to_currency]
  
   return {
       "original_amount": amount,
       "from_currency": from_currency,
       "to_currency": to_currency,
       "converted_amount": round(converted_amount, 2)
   }संचालित द्वारा

यह फ़ंक्शन तीन पैरामीटर लेता है: कन्वर्ट करने वाली राशि, स्रोत मुद्रा, और लक्ष्य मुद्रा। यह पूर्व-परिभाषित एक्सचेंज दरों का उपयोग करके सरल रूपांतरण करता है और कन्वर्ज़न विवरण के साथ एक स्ट्रक्चर्ड परिणाम लौटाता है।

Responses API के लिए फ़ंक्शन परिभाषित करना

अब, हमें मॉडल को अपने फ़ंक्शन के बारे में बताना है ताकि वह तय कर सके कि इसे कब कॉल करना है:

from openai import OpenAI
import json

client = OpenAI()

tools = [
   {
       "type": "function",
       "name": "convert_currency",
       "description": "Convert an amount from one currency to another using current exchange rates",
       "parameters": {
           "type": "object",
           "properties": {
               "amount": {
                   "type": "number",
                   "description": "The amount of money to convert"
               },
               "from_currency": {
                   "type": "string",
                   "description": "The currency code to convert from (e.g., USD, EUR, GBP)"
               },
               "to_currency": {
                   "type": "string",
                   "description": "The currency code to convert to (e.g., USD, EUR, GBP)"
               }
           },
           "required": ["amount", "from_currency", "to_currency"],
           "additionalProperties": False
       },
       "strict": True
   }
]संचालित द्वारा

यह परिभाषा स्पष्ट रूप से बताती है:

• फ़ंक्शन का नाम convert_currency जो हमारे Python फ़ंक्शन से मेल खाता है।
• एक विवरण जो समझाता है कि फ़ंक्शन कब उपयोग होना चाहिए।
• तीन आवश्यक पैरामीटर, उनके प्रकार और विवरण के साथ।
• strict: true फ़्लैग ताकि मॉडल हमारे पैरामीटर स्पेसिफिकेशंस का ठीक-ठीक पालन करे।

उपयोगकर्ता क्वेरी को हैंडल करना

आइए एक बातचीत का सिमुलेशन करें जहां उपयोगकर्ता करेंसी कन्वर्ज़न के बारे में पूछता है:

input_messages = [
   {"role": "user", "content": "How much is 100 euros in Japanese yen?"}
]

response = client.responses.create(
   model="gpt-4o",
   input=input_messages,
   tools=tools,
)संचालित द्वारा

जब मॉडल यह करेंसी कन्वर्ज़न से संबंधित सवाल देखता है, तो वह पहचानता है कि उसे हमारे फ़ंक्शन का उपयोग करना चाहिए। वह स्वतः पहचान लेता है कि:

• राशि 100 है
• स्रोत मुद्रा यूरो (EUR) है
• लक्ष्य मुद्रा जापानी येन (JPY) है

फ़ंक्शन कॉल प्रोसेस करना

अब हम फ़ंक्शन कॉल विवरण निकालते हैं और अपना फ़ंक्शन चलाते हैं:

tool_call = response.output[0]
print(f"Function called: {tool_call.name}")
print(f"Arguments: {tool_call.arguments}")

args = json.loads(tool_call.arguments)

# Execute the function with the parameters determined by the model
conversion_result = convert_currency(**args)
print(f"Function results: {conversion_result}")संचालित द्वारा

मॉडल ने नेचुरल लैंग्वेज क्वेरी को स्ट्रक्चर्ड पैरामीटर्स में अनुवाद कर दिया है। फिर हमारा फ़ंक्शन इन पैरामीटर्स के आधार पर गणना करता है और रूपांतरित राशि लौटाता है।

फ़ंक्शन परिणामों को मॉडल को लौटाना

अंत में, हम परिणामों को वापस मॉडल को भेजते हैं ताकि वह उपयोगकर्ता-अनुकूल प्रतिक्रिया बना सके:

input_messages.append(tool_call)  # append model's function call message
input_messages.append(
   {  # append result message
       "type": "function_call_output",
       "call_id": tool_call.call_id,
       "output": json.dumps(conversion_result)
   }
)

response_2 = client.responses.create(
   model="gpt-4o",
   input=input_messages,
   tools=tools,
)
print(response_2.output_text)
संचालित द्वारा

आउटपुट:

100 euros is equal to 16,473.12 Japanese yen based on current exchange rates.संचालित द्वारा

मॉडल ने हमारे कच्चे कन्वर्ज़न डाटा को एक स्वाभाविक, मानव-पठनीय प्रतिक्रिया में बदल दिया है। उसने संख्यात्मक परिणाम को ठीक से व्याख्यायित किया और मुद्रा के लिए उपयुक्त फ़ॉर्मेट में प्रस्तुत किया।

सब कुछ एक साथ लाना

एक वास्तविक एप्लिकेशन में, आप इस पूरे प्रोसेस को एक ऐसे एकल इंटरफ़ेस में समेटना चाहेंगे जो बातचीत के प्रवाह को सहजता से संभाले। यहां बताया गया है कि आप फ़ंक्शन कॉलिंग की पूरी प्रक्रिया को मैनेज करने वाला एक संपूर्ण असिस्टेंट कैसे बना सकते हैं:

def currency_assistant(user_message, conversation_history=None):
   """A complete assistant that handles currency conversion queries."""
   if conversation_history is None:
       conversation_history = []
  
   # Add the user's new message to the conversation
   conversation_history.append({"role": "user", "content": user_message})
  
   # Define available tools (our currency conversion function)
   tools = [{
       "type": "function",
       "name": "convert_currency",
       "description": "Convert an amount from one currency to another using current exchange rates",
       "parameters": {
           "type": "object",
           "properties": {
               "amount": {
                   "type": "number",
                   "description": "The amount of money to convert"
               },
               "from_currency": {
                   "type": "string",
                   "description": "The currency code to convert from (e.g., USD, EUR, GBP)"
               },
               "to_currency": {
                   "type": "string",
                   "description": "The currency code to convert to (e.g., USD, EUR, GBP)"
               }
           },
           "required": ["amount", "from_currency", "to_currency"],
           "additionalProperties": False
       },
       "strict": True
   }]
  
   # Get initial response from the model
   response = client.responses.create(
       model="gpt-4o",
       input=conversation_history,
       tools=tools,
   )
  
   # Check if the model wants to call a function
   if response.output and isinstance(response.output, list) and response.output[0].type == "function_call":
       tool_call = response.output[0]
      
       # Process the function call
       args = json.loads(tool_call.arguments)
       result = convert_currency(**args)
      
       # Add the function call and its result to the conversation
       conversation_history.append(tool_call)
       conversation_history.append({
           "type": "function_call_output",
           "call_id": tool_call.call_id,
           "output": json.dumps(result)
       })
      
       # Get the final response with the function results incorporated
       final_response = client.responses.create(
           model="gpt-4o",
           input=conversation_history,
           tools=tools,
       )
      
       return final_response.output_text, conversation_history
   else:
       # If no function call was needed, return the direct response
       return response.output_text, conversation_history

# Example usage
response, conversation = currency_assistant("How much is 50 British pounds in Australian dollars?")
print("Assistant:", response)

# Continue the conversation
response, conversation = currency_assistant("And what if I wanted to convert 200 Canadian dollars instead?", conversation)
print("Assistant:", response)संचालित द्वारा

यह इम्प्लीमेंटेशन:

1. फॉलो-अप प्रश्नों के लिए संदर्भ देने हेतु बातचीत का इतिहास बनाए रखती है।
2. एक ही इंटरफ़ेस में फ़ंक्शन कॉलिंग की पूरी प्रक्रिया संभालती है।
3. तय करती है कि कब फ़ंक्शन कॉलिंग आवश्यक है और कब मॉडल सीधे उत्तर दे सकता है।
4. मल्टी-टर्न बातचीत का समर्थन करती है जहां पिछला संदर्भ महत्वपूर्ण होता है।

इस दृष्टिकोण से, आप निर्बाध संवादात्मक अनुभव बना सकते हैं जहां उपयोगकर्ता स्वाभाविक रूप से इंटरैक्ट करते हैं—उन्हें पीछे चल रही जटिल फ़ंक्शन कॉलिंग का एहसास तक नहीं होता। असिस्टेंट, नेचुरल लैंग्वेज समझ, स्ट्रक्चर्ड फ़ंक्शन कॉल्स, और नेचुरल लैंग्वेज जनरेशन के बीच संक्रमण को संभालता है।

अधिक जटिल एप्लिकेशन बनाते समय आपको यह करने की आवश्यकता हो सकती है:

1. कई अलग-अलग क्वेरी प्रकारों के लिए कई फ़ंक्शंस का समर्थन करना।
2. संवेदनशील ऑपरेशंस के लिए प्रमाणीकरण और प्राधिकरण प्रबंधित करना।
3. अधिक परिष्कृत एरर हैंडलिंग और रिकवरी लागू करना।
4. फ़ंक्शन उपयोग और प्रदर्शन के लिए लॉगिंग और मॉनिटरिंग जोड़ना।
5. ऐसे यूज़र इंटरफ़ेस बनाना जो टेक्स्ट, वॉइस या मल्टीमॉडल इंटरैक्शन सपोर्ट करें।

फ़ंक्शन कॉलिंग, Responses API को आपकी सेवाओं और डाटा के साथ नेचुरल लैंग्वेज इनपुट्स को जोड़ने में सक्षम बनाती है। यह उपयोगकर्ता अनुरोधों और आपके व्यावसायिक सिस्टम्स के बीच एक पुल तैयार करती है—उपयोगकर्ता सादी भाषा में अनुरोध करते हैं और आपका एप्लिकेशन पृष्ठभूमि में तकनीकी इम्प्लीमेंटेशन संभालता है।

फ़ंक्शन कॉलिंग से आगे, Responses API की एक और शक्तिशाली क्षमता है स्ट्रक्चर्ड आउटपुट जनरेट करना। यह फ़ीचर फ़ंक्शन कॉलिंग का पूरक है क्योंकि यह आपकी एप्लिकेशन आवश्यकताओं के अनुरूप विशिष्ट फ़ॉर्मैट्स में प्रतिक्रियाएं प्राप्त करने का तरीका देता है।

Responses API के साथ स्ट्रक्चर्ड आउटपुट

AI एप्लिकेशन बनाते समय, अक्सर आपको अपने सिस्टम्स के साथ आसान इंटीग्रेशन के लिए प्रतिक्रियाएं किसी विशिष्ट फ़ॉर्मैट में चाहिए होती हैं। Responses API स्ट्रक्चर्ड आउटपुट सपोर्ट करती है, जिससे आपको मुक्त-रूप (फ्री-फ़ॉर्म) टेक्स्ट के बजाय सुव्यवस्थित, सुसंगत फ़ॉर्मैट में डाटा मिल सकता है। यह फ़ीचर विशेष रूप से तब मूल्यवान है जब आपको:

1. असंरचित टेक्स्ट से विशिष्ट जानकारी निकालनी हो।
2. उपयोगकर्ता इनपुट को स्ट्रक्चर्ड डाटा में बदलना हो।
3. डाउनस्ट्रीम प्रोसेसिंग के लिए सुसंगत प्रतिक्रिया फ़ॉर्मैट सुनिश्चित करने हों।
4. AI आउटपुट को सीधे डेटाबेस या APIs के साथ इंटीग्रेट करना हो।

स्ट्रक्चर्ड आउटपुट अतिरिक्त पार्सिंग और वैलिडेशन की ज़रूरत घटाते हैं, जिससे आपके एप्लिकेशन अधिक मज़बूत और रखरखाव में आसान बनते हैं।

वर्णनों से उत्पाद जानकारी निकालना

एक व्यावहारिक उदाहरण देखें: मान लें कि आप एक ई-कॉमर्स प्लेटफ़ॉर्म बना रहे हैं और आपको असंरचित उत्पाद वर्णनों से स्वतः उत्पाद विवरण निकालकर अपना डेटाबेस भरना है।

from openai import OpenAI
import json

client = OpenAI()

product_description = """
Our Premium Laptop Backpack is perfect for professionals and students alike.
Made with water-resistant material, it features padded compartments that fit
laptops up to 15.6 inches. The backpack includes 3 main storage areas,
5 smaller pockets, and has an integrated USB charging port. Available in
navy blue, black, and gray. Current retail price: $79.99, though it's
currently on sale for $64.99 until the end of the month.
"""

response = client.responses.create(
   model="gpt-4o",
   input=f"Extract structured product information from this description: {product_description}",
   text={
       "format": {
           "type": "json_schema",
           "name": "product_details",
           "schema": {
               "type": "object",
               "properties": {
                   "product_name": {"type": "string"},
                   "category": {"type": "string"},
                   "features": {"type": "array", "items": {"type": "string"}},
                   "colors": {"type": "array", "items": {"type": "string"}},
                   "pricing": {
                       "type": "object",
                       "properties": {
                           "regular_price": {"type": "number"},
                           "sale_price": {"type": "number"},
                           "currency": {"type": "string"},
                       },
                       "additionalProperties": False,
                       "required": ["regular_price", "sale_price", "currency"],
                   },
               },
               "required": ["product_name", "features", "colors", "pricing","category"],
               "additionalProperties": False,
           },
           "strict": True,
       }
   },
)

product_data = json.loads(response.output_text)
print(json.dumps(product_data, indent=2))संचालित द्वारा

आउटपुट:

{
 "product_name": "Premium Laptop Backpack",
 "category": "Backpack",
 "features": [
   "Water-resistant material",
   "Padded compartments for laptops up to 15.6 inches",
   "3 main storage areas",
   "5 smaller pockets",
   "Integrated USB charging port"
 ],
 "colors": [
   "Navy blue",
   "Black",
   "Gray"
 ],
 "pricing": {
   "regular_price": 79.99,
   "sale_price": 64.99,
   "currency": "USD"
 }
}संचालित द्वारा

यह स्वरूपित JSON डाटा अब सीधे आपके उत्पाद डेटाबेस के साथ इंटीग्रेट किया जा सकता है, जिससे कस्टम पार्सिंग लॉजिक की आवश्यकता समाप्त होती है और त्रुटियों की संभावना कम होती है।

स्ट्रक्चर्ड आउटपुट कॉन्फ़िगरेशन को समझना

प्रभावी और त्रुटिरहित स्ट्रक्चर्ड आउटपुट की कुंजी है अपना स्कीमा सही तरीके से परिभाषित करना। आइए कॉन्फ़िगरेशन के महत्वपूर्ण तत्वों को समझें:

text={
   "format": {
       "type": "json_schema",        # Specifies we're using JSON Schema
       "name": "product_details",    # A descriptive name for this schema
       "schema": {
           # Your JSON Schema definition here
           "type": "object",
           "properties": {
               # Each property with type information, e.g.
               "product_name": {"type": "string"},
               # ... other properties
           },
           "required": ["product_name", ...], # All other properties
           "additionalProperties": False
       },
       "strict": True                # Enforce schema constraints strictly
   }
}संचालित द्वारा

सबसे महत्वपूर्ण घटक हैं:

1. स्कीमा परिभाषा: संरचना का वर्णन करती है, जिसमें सभी प्रॉपर्टीज़ और उनके प्रकार शामिल हैं।
2. आवश्यक फ़ील्ड्स: वे प्रॉपर्टीज़ सूचीबद्ध करती हैं जिन्हें प्रतिक्रिया में शामिल होना चाहिए।
3. अतिरिक्त प्रॉपर्टीज़: False होने पर स्कीमा में परिभाषित नहीं की गई अतिरिक्त फ़ील्ड्स को रोकता है।
4. स्ट्रिक्ट मोड: True होने पर मॉडल को स्कीमा का सटीक पालन सुनिश्चित करता है।

स्ट्रक्चर्ड आउटपुट का उपयोग करने के व्यावहारिक सुझाव

बेहतर परिणामों के लिए ये दिशानिर्देश अपनाएं:

1. अपना स्कीमा सावधानी से डिज़ाइन करें: सभी आवश्यक फ़ील्ड्स शामिल करें, परंतु इसे आवश्यक जानकारी पर केंद्रित रखें।
2. उपयुक्त डाटा प्रकार उपयोग करें: अपने उपयोग के अनुरूप प्रकार चुनें (गणनाओं के लिए numbers, टेक्स्ट के लिए strings)।
3. स्पष्ट constraints सेट करें: सीमित विकल्पों वाले फ़ील्ड्स के लिए enum और संख्यात्मक सीमाओं के लिए minimum/maximum का उपयोग करें।
4. विविध इनपुट्स के साथ परीक्षण करें: सुनिश्चित करें कि आपका स्कीमा विभिन्न फ़ॉर्मैट्स और edge cases संभालता है।
5. स्पष्ट विवरण शामिल करें: फ़ील्ड्स में विवरण जोड़ने से मॉडल को समझने में मदद मिलती है कि क्या निकालना है।

Chat Completions API से तुलना

जहां Responses API JSON Schema के माध्यम से स्ट्रक्चर्ड आउटपुट देती है, वहीं Chat Completions API Pydantic मॉडलों का उपयोग करते हुए एक वैकल्पिक और अधिक सरल तरीका देती है:

from pydantic import BaseModel, Field
from typing import List, Optional
from openai import OpenAI

client = OpenAI()

class ProductDetails(BaseModel):
   product_name: str
   category: str = Field(default=None)
   features: List[str]
   specifications: Optional[dict] = None
   colors: List[str]
   pricing: dict

# With Chat Completions API
completion = client.beta.chat.completions.parse(
   model="gpt-4o",
   messages=[
       {"role": "system", "content": "Extract structured product information."},
       {"role": "user", "content": product_description}
   ],
   response_format=ProductDetails
)

pydantic_product = completion.choices[0].message.parsedसंचालित द्वारा

दोनों तरीकों के अपने लाभ हैं:

• Responses API सीधे API कॉल में मानक JSON Schema का उपयोग करती है
• Chat Completions API, Python के type system के साथ Pydantic के जरिए एकीकृत होती है

यदि आप मुझसे पूछें, तो मैं Chat Completions API का उपयोग करना पसंद करूंगा ताकि मुझे कच्चे JSON schemas नहीं लिखने पड़ें—बेशक तब तक, जब तक OpenAI Responses API में Pydantic मॉडलों का समर्थन नहीं जोड़ देता।

अधिक जानकारी के लिए देखें Structured Outputs के लिए Responses API दस्तावेज़।

निष्कर्ष

OpenAI Responses API, पिछले APIs की ताकतों को एकीकृत इंटरफ़ेस में मिलाकर डेवलपर्स के लिए भाषा मॉडलों के साथ इंटरैक्शन को सरल बनाती है, जिसमें कम कोड और कम जटिलता की जरूरत होती है। यह टेक्स्ट जनरेशन, इमेज विश्लेषण, फ़ंक्शन कॉलिंग और स्ट्रक्चर्ड आउटपुट को सपोर्ट करती है—जिससे AI क्षमताएं अधिक सुलभ होती हैं और डेवलपर्स इंटीग्रेशन चुनौतियों के बजाय व्यावसायिक समस्याओं के समाधान पर ध्यान केंद्रित कर पाते हैं।

Responses API के साथ अपनी यात्रा जारी रखते हुए, आप अपनी समझ को गहरा करने और इम्प्लीमेंटेशन कौशल बढ़ाने के लिए ये अतिरिक्त संसाधन उपयोगी पाएंगे:

• Working with the OpenAI API
• OpenAI Fundamentals Track
• GPT-4.5: OpenAI के नवीनतम मॉडल में नया क्या है
• OpenAI के साथ डीप रिसर्च
• GPT-4.5 फ़ंक्शन कॉलिंग ट्यूटोरियल
• GPT-4.5 API ट्यूटोरियल
• OpenAI Agents SDK ट्यूटोरियल