Responses API के साथ प्रतिक्रियाएँ उत्पन्न करें

10 मिनट्स

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

प्रतिक्रियाओं एपीआई को समझना

रिस्पॉन्स एपीआई पारंपरिक चैट पूर्णता की तुलना में कई लाभ प्रदान करता है:

स्टेटफुल बातचीत: कई मोड़ों पर बातचीत का संदर्भ बनाए रखता है
एकीकृत अनुभव: चैट पूर्णता और सहायक एपीआई पैटर्न को जोड़ता है
फाउंड्री डायरेक्ट मॉडल: न केवल OpenAI मॉडल के Azure बल्कि सीधे Microsoft फाउंड्री में होस्ट किए गए मॉडल के साथ काम करता है
सरल एकीकरण: OpenAI-संगत क्लाइंट के माध्यम से Access

नोट

रिस्पॉन्स एपीआई माइक्रोसॉफ्ट फाउंड्री अनुप्रयोगों में एआई प्रतिक्रियाएं उत्पन्न करने के लिए अनुशंसित दृष्टिकोण है। यह ज़्यादातर परिदृश्यों के लिए पुराने ChatCompletions API की जगह लेता है.

एक सरल प्रतिक्रिया उत्पन्न करना

OpenAI-संगत क्लाइंट के साथ, आप responses.create() विधि का उपयोग करके प्रतिक्रियाएँ उत्पन्न कर सकते हैं:

# Generate a response using the OpenAI-compatible client
response = openai_client.responses.create(
    model="gpt-4.1",  # Your model deployment name
    input="What is Microsoft Foundry?"
)

# Display the response
print(response.output_text)

इनपुट पैरामीटर आपके प्रॉम्प्ट वाले टेक्स्ट स्ट्रिंग को स्वीकार करता है। मॉडल इस इनपुट के आधार पर एक प्रतिक्रिया उत्पन्न करता है।

प्रतिक्रिया संरचना को समझना

एक प्रतिक्रिया ऑब्जेक्ट में कई उपयोगी गुण होते हैं:

output_text: उत्पन्न पाठ प्रतिक्रिया
id: इस प्रतिक्रिया के लिए युनीक आइडेंटिफ़ायर
स्थिति: प्रतिक्रिया स्थिति (उदाहरण के लिए, "पूर्ण")
उपयोग: टोकन उपयोग की जानकारी (इनपुट, आउटपुट और कुल टोकन)
मॉडल: प्रतिक्रिया उत्पन्न करने के लिए उपयोग किया जाने वाला मॉडल

प्रतिक्रियाओं को प्रभावी ढंग से संभालने के लिए आप इन गुणों तक access सकते हैं:

response = openai_client.responses.create(
    model="gpt-4.1",
    input="Explain machine learning in simple terms."
)

print(f"Response: {response.output_text}")
print(f"Response ID: {response.id}")
print(f"Tokens used: {response.usage.total_tokens}")
print(f"Status: {response.status}")

निर्देश जोड़ना

उपयोगकर्ता इनपुट के अलावा, आप मॉडल के व्यवहार का मार्गदर्शन करने के लिए निर्देश (अक्सर सिस्टम प्रॉम्प्ट के रूप में संदर्भित) प्रदान कर सकते हैं:

response = client.responses.create(
    model="gpt-4.1",
    instructions="You are a helpful AI assistant that answers questions clearly and concisely.",
    input="Explain neural networks."
)

print(response.output_text)

प्रतिक्रिया पीढ़ी को नियंत्रित करना

आप अतिरिक्त मापदंडों के साथ प्रतिक्रिया पीढ़ी को नियंत्रित कर सकते हैं:

response = openai_client.responses.create(
    model="gpt-4.1",
    instructions="You are a helpful AI assistant that answers questions clearly and concisely.",
    input="Write a creative story about AI.",
    temperature=0.8,  # Higher temperature for more creativity
    max_output_tokens=200  # Limit response length
)

print(response.output_text)

तापमान: यादृच्छिकता (0.0-2.0) को नियंत्रित करता है। उच्च मान आउटपुट को अधिक रचनात्मक और विविध बनाते हैं
max_output_tokens: प्रतिक्रिया में टोकन की अधिकतम संख्या को सीमित करता है
top_p: यादृच्छिकता को नियंत्रित करने के लिए तापमान का विकल्प

फाउंड्री प्रत्यक्ष मॉडल के साथ काम करना

प्रोजेक्ट एंडपॉइंट से कनेक्ट करने के लिए FoundrySDK या AzureOpenAI क्लाइंट का उपयोग करते समय, रिस्पॉन्स API Azure OpenAI मॉडल और फाउंड्री डायरेक्ट मॉडल (जैसे Microsoft Phi, DeepSeek, या Microsoft Foundry में सीधे होस्ट किए गए अन्य मॉडल) दोनों के साथ काम करता है:

# Using a Foundry direct model
response = openai_client.responses.create(
    model="microsoft-phi-4",  # Example Foundry direct model
    instructions="You are a helpful AI assistant that answers questions clearly and concisely.",
    input="What are the benefits of small language models?"
)

print(response.output_text)

बातचीत के अनुभव बनाना

अधिक जटिल संवादी परिदृश्यों के लिए, आप सिस्टम निर्देश प्रदान कर सकते हैं और बहु-मोड़ वार्तालाप बना सकते हैं:

# First turn in the conversation
response1 = openai_client.responses.create(
    model="gpt-4.1",
    instructions="You are a helpful AI assistant that explains technology concepts clearly.",
    input="What is machine learning?"
)

print("Assistant:", response1.output_text)

# Continue the conversation
response2 = openai_client.responses.create(
    model="gpt-4.1",
    instructions="You are a helpful AI assistant that explains technology concepts clearly.",
    input="Can you give me an example?",
    previous_response_id=response1.id
)

print("Assistant:", response2.output_text)

वास्तव में, कार्यान्वयन को एक लूप के रूप में बनाए जाने की संभावना है जिसमें उपयोगकर्ता मॉडल से प्राप्त प्रत्येक प्रतिक्रिया के आधार पर अंतःक्रियात्मक रूप से संदेश दर्ज कर सकता है:

# Track responses
last_response_id = None

# Loop until the user wants to quit
print("Assistant: Enter a prompt (or type 'quit' to exit)")
while True:
    input_text = input('\nYou: ')
    if input_text.lower() == "quit":
        print("Assistant: Goodbye!")
        break

    # Get a response
    response = openai_client.responses.create(
                model=model_name,
                instructions="You are a helpful AI assistant that explains technology concepts clearly.",
                input=input_text,
                previous_response_id=last_response_id
    )
    assistant_text = response.output_text
    print("\nAssistant:", assistant_text)
    last_response_id = response.id

इस उदाहरण से आउटपुट इस तरह दिखता है:

Assistant: Enter a prompt (or type 'quit' to exit)

You: What is machine learning?

Assistant: Machine learning is a type of artificial intelligence (AI) that enables computers to learn from data and improve their performance over time without being explicitly programmed. It involves training algorithms on large datasets to recognize patterns, make predictions, or take actions based on those patterns. This allows machines to become more accurate and efficient in their tasks as they are exposed to more data.

You: Can you give me an example?

Assistant: Certainly! Let's look at a simple example of supervised learning—predicting house prices based on features like size, location, and number of rooms.
Imagine you want to build a machine learning model that can predict the price of a house based on various factors.
...
    { the example provided in the model response may be extensive}
...

You: quit

Assistant: Goodbye!

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

वैकल्पिक: मैनुअल वार्तालाप श्रृंखलाएँ

आप संदेश इतिहास स्वयं बनाकर वार्तालापों को मैन्युअल रूप से प्रबंधित कर सकते हैं। यह दृष्टिकोण आपको इस बात पर अधिक नियंत्रण देता है कि कौन सा संदर्भ शामिल है:

try:
    # Start with initial message
    conversation_history = [
        {
            "type": "message",
            "role": "user",
            "content": "What is machine learning?"
        }
    ]
    
    # First response
    response1 = openai_client.responses.create(
        model="gpt-4.1",
        input=conversation_history
    )
    
    print("Assistant:", response1.output_text)
    
    # Add assistant response to history
    conversation_history += response1.output
    
    # Add new user message
    conversation_history.append({
        "type": "message",
        "role": "user", 
        "content": "Can you give me an example?"
    })
    
    # Second response with full history
    response2 = openai_client.responses.create(
        model="gpt-4.1",
        input=conversation_history
    )
    
    print("Assistant:", response2.output_text)

except Exception as ex:
    print(f"Error: {ex}")

यह मैनुअल दृष्टिकोण तब उपयोगी होता है जब आपको इसकी आवश्यकता होती है:

अनुकूलित करें कि कौन से संदेश संदर्भ में शामिल हैं
टोकन सीमाओं को प्रबंधित करने के लिए वार्तालाप छंटाई लागू करें
किसी डेटाबेस से वार्तालाप इतिहास संग्रहीत और पुनर्स्थापित करें

विशिष्ट पिछली प्रतिक्रियाओं को पुनर्प्राप्त करना

रिस्पॉन्स एपीआई प्रतिक्रिया इतिहास बनाए रखता है, जिससे आप पिछली प्रतिक्रियाओं को पुनः प्राप्त कर सकते हैं:

try:   
   
    # Retrieve a previous response
    response_id = "resp_67cb61fa3a448190bcf2c42d96f0d1a8"  # Example ID
    previous_response = openai_client.responses.retrieve(response_id)
    
    print(f"Previous response: {previous_response.output_text}")

except Exception as ex:
    print(f"Error: {ex}")

संदर्भ विंडो विचार

previous_response_id पैरामीटर प्रतिक्रियाओं को एक साथ जोड़ता है, कई एपीआई कॉल में बातचीत के संदर्भ को बनाए रखता है।

यह ध्यान रखना महत्वपूर्ण है कि बातचीत का इतिहास रखने से टोकन का उपयोग बढ़ सकता है। एक रन के लिए, सक्रिय संदर्भ विंडो में शामिल हो सकते हैं:

सिस्टम निर्देश (निर्देश, सुरक्षा नियम)
आपका वर्तमान संकेत
वार्तालाप इतिहास (पिछला उपयोगकर्ता + सहायक संदेश)
टूल स्कीमा (फ़ंक्शन, ओपनएपीआई स्पेक्स, एमसीपी टूल, आदि)
टूल आउटपुट (खोज परिणाम, कोड दुभाषिया आउटपुट, फ़ाइलें)
पुनर्प्राप्त स्मृति या दस्तावेज़ (मेमोरी स्टोर, आरएजी, फ़ाइल खोज से)

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

रिस्पॉन्सिव चैट ऐप्स बनाना

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

स्ट्रीमिंग प्रतिक्रियाएं

लंबी प्रतिक्रियाओं के लिए, आप आउटपुट प्राप्त करने के लिए स्ट्रीमिंग का उपयोग कर सकते हैं - इसलिए आउटपुट उपलब्ध होने पर उपयोगकर्ता आंशिक रूप से पूर्ण प्रतिक्रियाएं देखता है:

stream = openai_client.responses.create(
    model="gpt-4.1",
    input="Write a short story about a robot learning to paint.",
    stream=True
)

for event in stream:
    print(event, end="", flush=True)

अगर आप स्ट्रीमिंग करते समय बातचीत के इतिहास को ट्रैक कर रहे हैं, तो स्ट्रीम खत्म होने पर आपको जवाब आईडी मिल सकती है, जैसे:

stream = openai_client.responses.create(
    model="gpt-4.1",
    input="Write a short story about a robot learning to paint.",
    stream=True
)
for event in stream:
                if event.type == "response.output_text.delta":
                    print(event.delta, end="")
                elif event.type == "response.completed":
                    response_id = event.response.id

Async उपयोग

उच्च-प्रदर्शन अनुप्रयोगों के लिए, आप एक अतुल्यकालिक क्लाइंट का उपयोग कर सकते हैं जो आपको गैर-अवरुद्ध एपीआई कॉल करने की अनुमति देता है। अतुल्यकालिक उपयोग लंबे समय तक चलने वाले अनुरोधों के लिए आदर्श है या जब आप अपने एप्लिकेशन को अवरुद्ध किए बिना एक साथ कई अनुरोधों को संभालना चाहते हैं। इसका उपयोग करने के लिए, इसके बजाय आयात AsyncOpenAI करें OpenAI और प्रत्येक एपीआई कॉल के साथ उपयोग करेंawait:

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://<resource-name>.openai.azure.com/openai/v1/",
    api_key=token_provider,
)

async def main():
    response = await client.responses.create(
        model="gpt-4.1",
        input="Explain quantum computing briefly."
    )
    print(response.output_text)

asyncio.run(main())

Async स्ट्रीमिंग उसी तरह काम करती है:

async def stream_response():
    stream = await client.responses.create(
        model="gpt-4.1",
        input="Write a haiku about coding.",
        stream=True
    )
    
    async for event in stream:
        print(event, end="", flush=True)

asyncio.run(stream_response())

Microsoft फाउंड्री SDK के माध्यम से Responses API का उपयोग करके, आप परिष्कृत संवादात्मक AI एप्लिकेशन बना सकते हैं जो संदर्भ बनाए रखते हैं, कई मॉडल प्रकारों का समर्थन करते हैं, और एक उत्तरदायी उपयोगकर्ता अनुभव प्रदान करते हैं।

प्रतिक्रिया

क्या यह पेज मददगार था?