API और इंटीग्रेशन

Mistral Responses API: Large 4 सेटअप और OpenAI से माइग्रेशन

Mistral Large 4 का पहला अनुरोध चलाएँ और OpenAI Responses इंटीग्रेशन को Mistral के स्टेटलेस API के अनुसार बदलें। असमर्थित पैरामीटर, मॉडल के अनुसार रीज़निंग स्तर, पूरी बातचीत का इतिहास, फ़ंक्शन के नतीजे और इनपुट टोकन की गिनती समझें। सर्वर पर सहेजी गई बातचीत या होस्ट किए गए टूल चाहिए तो Conversations API चुनें।

BetterToken

संपादकीय टीम

1 नव॰ 202611 मिनट पढ़ने में

विषय-सूची

Mistral Responses API: Large 4 सेटअप और OpenAI से माइग्रेशन

Mistral Responses API में mistral-large-4 इस्तेमाल करें और हर अनुरोध के input में बातचीत का इतिहास भेजें। सर्वर पर बातचीत आगे बढ़ाने वाले पैरामीटर हटाएँ, store बंद रखें और मॉडल के अनुसार reasoning.effort का मान चुनें। 2026-11-01 तक Mistral का Responses API सार्वजनिक प्रीव्यू में है।

Mistral Large 4 का पहला अनुरोध चलाएँ

पहले अनुरोध के लिए Mistral का मौजूदा Python SDK और Mistral की API कुंजी इस्तेमाल करें। इस दस्तावेज़ित उदाहरण को आधार बनाकर आप अपना मौजूदा Responses क्लाइंट बदल सकते हैं।

Python 3.10 या नया संस्करण चाहिए। Studio → API keys में कुंजी बनाएँ और ये कमांड Bash में चलाएँ। जब read इनपुट का इंतज़ार करे, कुंजी पेस्ट करके Enter दबाएँ। कुंजी स्क्रीन पर नहीं दिखेगी।

python3 -m pip install -U mistralai
read -rs MISTRAL_API_KEY && export MISTRAL_API_KEY

नीचे दिया कोड mistral_responses.py में सहेजें। सहायक फ़ंक्शन बाद के उदाहरणों में निर्देश और अनुरोध की सेटिंग एक जैसी रखता है।

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
MODEL = "mistral-large-4"
INSTRUCTIONS = "Answer concisely."

def create_response(history, **options):
    result = client.responses.create(
        model=MODEL,
        input=history,
        instructions=INSTRUCTIONS,
        reasoning={"effort": "high"},
        max_output_tokens=4096,
        additional_properties={
            "store": False,
            "background": False,
            "truncation": "disabled",
        },
        **options,
    )
    if result.status != "completed":
        raise RuntimeError(
            f"{result.status}: {result.error or result.incomplete_details}"
        )
    return result

def answer_text(result):
    return "".join(
        part.text
        for item in result.output if item.type == "message"
        for part in item.content if part.type == "output_text"
    )

history = [{"role": "user", "content": "Explain a stateless API in one sentence."}]
response = create_response(history)
print(response.status)
print(answer_text(response))

इसे उसी Bash सत्र में चलाएँ:

python3 mistral_responses.py

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

HTTP एंडपॉइंट https://api.mistral.ai/v1/responses है। सीधे HTTP अनुरोध में Authorization: Bearer $MISTRAL_API_KEY हेडर इस्तेमाल करें। अगर क्लाइंट खुद /responses जोड़ता है, तो उसका बेस URL https://api.mistral.ai/v1 रखें।

बाकी Python उदाहरण इसी फ़ाइल के वेरिएबल और सहायक फ़ंक्शन दोबारा इस्तेमाल करते हैं। ज़रूरत वाले उदाहरण फ़ाइल के अंत में जोड़ें। फ़ाइल फिर चलाने पर उसमें शामिल सभी जनरेशन अनुरोध दोबारा चलेंगे।

OpenAI Responses के कौन-से पैरामीटर बदलने होंगे?

OpenAI Responses का अनुरोध दोबारा इस्तेमाल करने से पहले HTTP JSON फ़ील्ड को इन नियमों के अनुसार बदलें। Mistral के Responses API संदर्भ में 2026-11-01 तक स्वीकार्य मान दिए गए हैं।

अनुरोध का पैरामीटर	Mistral की शर्त	माइग्रेशन में बदलाव
`previous_response_id`	इसे छोड़ दें या `null` भेजें।	पिछले उत्तरों के आइटम `input` में दोबारा भेजें।
`conversation`	इसे छोड़ दें या `null` भेजें।	बातचीत का इतिहास अपने एप्लिकेशन में रखें।
`store`	इसे छोड़ दें, या `false` अथवा `null` भेजें।	`true` हटाएँ; सहेजे गए उत्तरों पर निर्भर न रहें।
`background`	`false` होना चाहिए; यही डिफ़ॉल्ट है।	पृष्ठभूमि में चलाना और उसकी स्थिति बार-बार पूछना हटाएँ।
`truncation`	`"disabled"` होना चाहिए; यही डिफ़ॉल्ट भी है।	अनुरोध भेजने से पहले संदर्भ का आकार सँभालें।
`prompt`	इसे छोड़ दें या `null` भेजें।	प्रॉम्प्ट का पाठ `input` और `instructions` में रखें।
`moderation`	इसे छोड़ दें या `null` भेजें।	संगतता के लिए मौजूद इस फ़ील्ड में भरा मान हटाएँ।
`top_logprobs`	इसे छोड़ दें, या `0` अथवा `null` भेजें।	सकारात्मक मान हटाएँ।
`max_tool_calls`	स्वीकार होता है, लेकिन फ़िलहाल अनदेखा किया जाता है।	निष्पादन की सीमाएँ अपने एप्लिकेशन में लागू करें।
`reasoning.effort`	चुना मॉडल उस मान को स्वीकार करे।	नीचे दिए मॉडल के अनुसार मान चुनें।
`tools`	एप्लिकेशन में चलने वाले फ़ंक्शन; इन्हें नेमस्पेस में समूहित कर सकते हैं।	प्रदाता के सर्वर पर चलने वाले टूल पर निर्भरता बदलें।
`max_output_tokens`	रीज़निंग और उत्तर के पाठ, दोनों के टोकन शामिल हैं।	दोनों हिस्सों के लिए पर्याप्त आउटपुट बजट रखें।

Python SDK के कीवर्ड आर्ग्युमेंट हर HTTP फ़ील्ड से सीधे मेल नहीं खाते। इसकी मौजूदा Responses इम्प्लीमेंटेशन में store, background और truncation को additional_properties के ज़रिए भेजते हैं। पहला उदाहरण यही तरीका इस्तेमाल करता है।

प्रदाता की सेटिंग में ये अंतर बनाए रखें। सिर्फ एंडपॉइंट बदलने से सभी टूल, बातचीत जारी रखने के तरीके और स्ट्रीमिंग हैंडलर की संगतता साबित नहीं होती। Messages, Chat Completions और Responses की संगतता का मार्गदर्शन बताता है कि फ़ंक्शन कॉल का पूरा चक्र जाँचना क्यों ज़रूरी है।

कौन-से मॉडल और सुविधाएँ उपलब्ध हैं?

इन उदाहरणों के लिए mistral-large-4 इस्तेमाल करें और मॉडल बदलते समय उसकी क्षमताएँ दोबारा जाँचें। Mistral की लॉन्च घोषणा के अनुसार, यह उसके होस्ट किए गए सभी चैट मॉडल के साथ काम करता है, जिनमें Large 4 शामिल है।

समर्थित सुविधाओं की सूची में पाठ का इनपुट और आउटपुट, संरचित आउटपुट, स्ट्रीमिंग, फ़ंक्शन और मॉडल के अनुसार रीज़निंग शामिल हैं। चित्र भेजने के लिए चित्र समझने वाला मॉडल चाहिए; चित्र का URL या base64 डेटा URL भेज सकते हैं। फ़ाइल के लिए HTTPS URL, base64 डेटा URL या अपलोड की गई फ़ाइल का ID भेज सकते हैं; समर्थन मॉडल पर निर्भर है।

संरचित आउटपुट में JSON मोड या JSON Schema के लिए text.format इस्तेमाल होता है। फ़ंक्शन आपके एप्लिकेशन में चलते हैं। प्रकाशित इम्प्लीमेंटेशन केवल क्लाइंट पर चलने वाले फ़ंक्शन स्वीकार करता है, इसलिए होस्ट किए गए web_search टूल को बिना बदलाव न भेजें।

रीज़निंग, यानी मॉडल के तर्क करने का प्रयास, Responses के नेस्टेड फ़ील्ड reasoning.effort से चुनें। ये मान Mistral के रीज़निंग मार्गदर्शन के अनुसार हैं, जिसे 2026-11-01 को जाँचा गया था:

मॉडल	समर्थित मान	किस स्थिति में चुनें
`mistral-large-4` / `mistral-large-4-0`	`low`, `medium`, `high`	उदाहरण के लिए `high` से शुरू करें। देरी या टोकन खर्च अहम हो तो कम स्तरों की तुलना करें।
`mistral-small-2603`	`none`, `high`	रीज़निंग मोड चाहिए तो `high` इस्तेमाल करें।
`mistral-medium-3-5`	`none`, `high`	मौजूदा इंटीग्रेशन के लिए; मॉडल को अप्रचलित (deprecated) चिह्नित किया गया है।

Large 4 में none, minimal, xhigh और max स्वीकार नहीं होते। अगर आपने Large 4 के शुरुआती प्रीव्यू के उदाहरण लिए थे, तो none की जगह low रखें। SDK की साझा मान-सूची में कोई मान होने से यह न मानें कि हर मॉडल उसे स्वीकार करता है।

Large 4 के मॉडल कार्ड में भी सार्वजनिक प्रीव्यू का दर्जा दिया गया है। Medium 3.5 के कार्ड में अप्रचलित घोषित करने की तारीख 2026-10-31 है। नए इंटीग्रेशन के लिए Mistral, Large 4 की सिफ़ारिश करता है।

कई दौर की बातचीत और फ़ंक्शन के नतीजे कैसे भेजें?

रीज़निंग और फ़ंक्शन कॉल समेत सभी आइटम का पूरा इतिहास रखें। केवल दिखाने लायक उत्तर का पाठ बातचीत का पूरा रिकॉर्ड नहीं है।

बातचीत आगे बढ़ाएँ

पिछले output का हर आइटम जोड़ें, फिर उपयोगकर्ता का अगला संदेश जोड़ें। पहले उदाहरण के बाद यह कोड रखें:

history.extend(response.output)
history.append({"role": "user", "content": "What must the client send next time?"})
response = create_response(history)
print(answer_text(response))
history.extend(response.output)

दूसरे अनुरोध में उपयोगकर्ता का पहला संदेश, पूरा पहला उत्तर और अगला सवाल शामिल हैं। सहायक फ़ंक्शन instructions भी दोबारा भेजता है।

यह previous_response_id की जगह इस्तेमाल करने का दस्तावेज़ित तरीका है। केवल उत्तर का ID रखने से इस स्टेटलेस एंडपॉइंट को इतिहास नहीं मिलता। सिर्फ दिखाया गया उत्तर सहेजने पर बाकी लौटाए गए आइटम छूट जाते हैं।

फ़ंक्शन का नतीजा लौटाएँ

फ़ंक्शन स्थानीय रूप से चलाएँ और उसका नतीजा संबंधित call_id के साथ भेजें। Mistral के फ़ंक्शन कॉल के उदाहरण में type, name, description और parameters एक ही टूल ऑब्जेक्ट में हैं। अगला उदाहरण इसी संरचना से स्थानीय जोड़ करता है और अलग इतिहास रखता है।

import json

TOOLS = [{
    "type": "function",
    "name": "add",
    "description": "Add two integers.",
    "parameters": {
        "type": "object",
        "properties": {
            "a": {"type": "integer"},
            "b": {"type": "integer"},
        },
        "required": ["a", "b"],
        "additionalProperties": False,
    },
}]
tool_history = [{"role": "user", "content": "Use add to calculate 19 + 23."}]
response = create_response(
    tool_history,
    tools=TOOLS,
    tool_choice={"type": "function", "name": "add"},
    parallel_tool_calls=False,
)
tool_history.extend(response.output)

calls = [item for item in response.output if item.type == "function_call"]
if len(calls) != 1 or calls[0].name != "add":
    raise RuntimeError("Expected exactly one add call.")

call = calls[0]
args = json.loads(call.arguments)
if (
    not isinstance(args, dict)
    or set(args) != {"a", "b"}
    or any(type(args[name]) is not int for name in ("a", "b"))
):
    raise ValueError("Expected two integer arguments.")

result = args["a"] + args["b"]
print("Local result:", result)
tool_history.append({
    "type": "function_call_output",
    "call_id": call.call_id,
    "output": json.dumps({"result": result}),
})
response = create_response(
    tool_history,
    tools=TOOLS,
    tool_choice="none",
    parallel_tool_calls=False,
)
print(answer_text(response))
tool_history.extend(response.output)

जाँचें कि Local result: 42 दिखे और उसके बाद का उत्तर इसी नतीजे का इस्तेमाल करे। मॉडल के शब्द बदल सकते हैं।

पहला अनुरोध add का कॉल अनिवार्य करता है। दूसरे में "none" आगे की कॉल बंद करता है, जैसा API संदर्भ में बताया गया है। इससे उदाहरण दो जनरेशन चरण और एक स्थानीय निष्पादन तक सीमित रहता है।

एजेंट के ऐसे लूप में, जिसके चरण पहले से तय नहीं हैं, दौर और निष्पादन की सीमाएँ खुद लागू करें। max_tool_calls अनदेखा किया जाता है।

फ़ंक्शन के नतीजे जोड़ने से पहले लौटाया गया पूरा आउटपुट सहेजें। नतीजे का मिलान call_id से करें, आउटपुट आइटम के id से नहीं। कई फ़ंक्शन कॉल की अनुमति हो तो अगला उत्तर माँगने से पहले हर कॉल जाँचें और उसका नतीजा लौटाएँ।

इतिहास बढ़ने से पहले इनपुट टोकन गिनें

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

फ़ंक्शन वाले उदाहरण के बाद यह कोड इस्तेमाल करें:

next_input = tool_history + [
    {"role": "user", "content": "Explain that calculation in one sentence."}
]
count = client.responses.count_input_tokens(
    model=MODEL,
    input=next_input,
    instructions=INSTRUCTIONS,
    tools=TOOLS,
    reasoning={"effort": "high"},
    parallel_tool_calls=False,
    tool_choice="auto",
)
print(count.input_tokens)

यह POST /v1/responses/input_tokens को कॉल करके input_tokens दिखाता है। यह उत्तर बनाए बिना इनपुट गिनता है। बाद में उत्तर बनवाते समय वही मॉडल, इनपुट, निर्देश और टूल इस्तेमाल करें।

इस गिनती की तुलना चुने मॉडल की कॉन्टेक्स्ट विंडो से करें और आउटपुट के लिए जगह छोड़ें। truncation को "disabled" रखना ज़रूरी है, इसलिए इतिहास कब घटाना है, यह एप्लिकेशन तय करेगा।

इतिहास सँभालते समय हर फ़ंक्शन कॉल को उसके नतीजे के साथ रखें। टूल के साथ हुए आदान-प्रदान के बीच से मनमाने आइटम न हटाएँ।

टोकन की गिनती लागत का अनुमान नहीं है। कई दौर की बातचीत और कैश के असर से होने वाला खर्च आँकते समय Mistral की मौजूदा API दरें देखें।

माइग्रेशन की समस्याएँ कैसे जाँचें?

पहले अनुरोध की सेटिंग जाँचें, फिर स्थिति और आउटपुट आइटम देखें। अपने लक्षण के अनुसार जाँच चुनें।

SDK अनुरोध भेजने से पहले कीवर्ड आर्ग्युमेंट अस्वीकार कर देता है। स्थापित SDK और मेथड के आर्ग्युमेंट जाँचें। यहाँ इस्तेमाल SDK में store, background और truncation को additional_properties के अंदर रखें।
API अनुरोध अस्वीकार कर देता है। पहले पाठ वाले उदाहरण पर लौटें। मॉडल का ID, समर्थित रीज़निंग स्तर और संगतता तालिका जाँचें। अनुरोध सफल होने के बाद वैकल्पिक फ़ील्ड एक-एक करके वापस जोड़ें।
मॉडल पहले का संदर्भ भूल जाता है। अगला input ऐरे देखें। उसमें पुराने संदेश और पूरे आउटपुट आइटम होने चाहिए, केवल उत्तर का ID नहीं।
उत्तर में पाठ नहीं है। status, error और incomplete_details देखें। जाँचें कि कोई फ़ंक्शन कॉल निष्पादन का इंतज़ार तो नहीं कर रही। आउटपुट बजट खत्म हुआ हो तो उसे बढ़ाएँ या मॉडल के समर्थित विकल्पों में से कम रीज़निंग स्तर चुनें।
अनुरोध गलत पथ पर जाता है। अंतिम URL का मिलान https://api.mistral.ai/v1/responses से करें। बेस URL, एंडपॉइंट और त्रुटियों की जाँच का मार्गदर्शन पथ बनाने की आम गलतियाँ समझाता है।

स्ट्रीमिंग के लिए stream=True रखें और Responses के इवेंट पढ़ें। आधिकारिक Python स्ट्रीमिंग उदाहरण हर इवेंट को frame.data से पढ़ता है। पाठ response.output_text.delta में आता है; response.completed पूरा होने का संकेत देता है।

response.failed, response.incomplete और error इवेंट भी सँभालें। पाठ का एक हिस्सा मिलने भर से सफल समापन साबित नहीं होता। पृष्ठभूमि में जनरेशन बंद है, इसलिए यहाँ स्थिति पूछते रहने वाला पोलिंग लूप नहीं चाहिए।

Responses, Chat Completions या Conversations में क्या चुनें?

Responses चुनें जब उसका आइटम-आधारित प्रारूप आपके एप्लिकेशन के अनुकूल हो और इतिहास व फ़ंक्शन निष्पादन आपके नियंत्रण में हों।

एप्लिकेशन की ज़रूरत	किससे शुरू करें	कारण
Responses के इनपुट/आउटपुट आइटम और स्ट्रीमिंग इवेंट	Responses API	वही प्रारूप रहता है; स्थिति और फ़ंक्शन आपका एप्लिकेशन सँभालता है।
संदेशों पर आधारित मौजूदा इंटीग्रेशन	Chat Completions	संदेश-आधारित अनुरोध और उत्तर सँभालने का मौजूदा तरीका रख सकते हैं।
सहेजी गई बातचीत आगे बढ़ाना या Mistral के सर्वर पर चलने वाले टूल	Conversations API	बातचीत के ID और सर्वर पर चलने वाले टूल के लिए अलग इंटरफ़ेस मिलता है।

Mistral का Chat Completions मार्गदर्शन संदेशों पर आधारित प्रारूप समझाता है। Conversations संदर्भ बताता है कि conversation_id से बातचीत कैसे जारी रखें।

सर्वर पर खोज के लिए Mistral ने web_search और web_search_premium को Conversations और Agents में दस्तावेज़ित किया है। यह सुविधा Responses के क्लाइंट पर चलने वाले फ़ंक्शन से अलग है।

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