OpenAPI 3.1

ग्राहक API संदर्भ

यह पृष्ठ समर्थित ग्राहक inference अनुरोध और उत्तर का विवरण देता है। टूलिंग के लिए मशीन-पठनीय OpenAPI दस्तावेज़ डाउनलोड करें।

OpenAPI JSON डाउनलोड करें

मॉडल API के उदाहरण

मॉडल से उत्तर पाने का अनुरोध देखने के लिए प्रकाशित मॉडल पहचानकर्ता, API प्रोटोकॉल और भाषा चुनें। ग्राहक की API कुंजी केवल विश्वसनीय सर्वर पर रखें।

मॉडल

भाषा

प्रोटोकॉल की आवश्यकताएँ

OpenAI-संगत अनुरोधों के लिए निर्धारित ग्राहक API आधार URL पर POST /chat/completions भेजें (डिफ़ॉल्ट https://fusionpointai.com/api/v1 है)। मॉडल से उत्तर पाने की अनुमति वाली ग्राहक कुंजी के साथ Authorization: Bearer से प्रमाणित करें। पूरा डिफ़ॉल्ट URL https://fusionpointai.com/api/v1/chat/completions है।

समर्थित क्षमताएँ

मौजूदा OpenAI-संगत chat एंडपॉइंट समकालिक text संदेश संभालता है। इस एंडपॉइंट पर streaming और tool calls समर्थित नहीं हैं।

क्लाइंट इंस्टॉल करें

Python और Node.js क्लाइंट अलग-अलग पैकेज के रूप में इंस्टॉल करें:

Python: pip install openai anthropic

Node.js: npm install openai @anthropic-ai/sdk

curl 'https://fusionpointai.com/api/v1/chat/completions' \
  -H "Authorization: Bearer $FUSIONPOINTAI_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "Astra 6",
    "messages": [
        {
            "role": "user",
            "content": "Summarize this in one sentence."
        }
    ],
    "temperature": 0.7,
    "max_tokens": 300
}'

अनुरोध के तरीके

API कुंजियाँ सुरक्षित रखें

मॉडल से उत्तर पाने की अनुमति वाली ग्राहक API कुंजी बनाएँ और उसे सुरक्षित रहस्य-संग्रह या सर्वर की सुरक्षित setting में रखें।

सर्वर की सुरक्षित setting में FUSIONPOINTAI_API_KEY रखें; कुंजी browser code में न रखें और source control में जमा न करें।
HTTPS का उपयोग करें और कुंजी को केवल उस खाते तथा मॉडल से उत्तर पाने की अनुमतियों तक सीमित रखें जिनकी अनुप्रयोग को जरूरत है।
लॉग, अनुरोध की निगरानी से जुड़े विवरण और सहायता संदेशों से authorization तथा x-api-key headers छिपाएँ; कुंजी उजागर होने की आशंका हो तो उसे रद्द करें।

export FUSIONPOINTAI_API_KEY="YOUR_CUSTOMER_API_KEY"

सटीक मॉडल पहचानकर्ता चुनें

मॉडल फ़ील्ड routing के लिए है, दिखाए जाने वाले नाम के लिए नहीं। लाइव मॉडल कैटलॉग में प्रकाशित पहचानकर्ता चुनें।

ऐसा सक्रिय या पुराना मॉडल चुनें जिसे अनुरोध भेजने के लिए उपलब्ध दिखाया गया हो।
विराम-चिह्न और version suffix सहित पहचानकर्ता ज्यों का त्यों कॉपी करें; मॉडल के नाम से ID न बनाएँ।
पहचानकर्ता प्रकाशित न हो तो अनुमान लगाने के बजाय कैटलॉग में उसके आने की प्रतीक्षा करें।

model_id = "Astra 6"
# Use this exact identifier with either protocol.

सिस्टम और कई दौर के संदेश भेजें

बातचीत के संदेशों का क्रम बनाए रखें और चुने गए प्रोटोकॉल तथा मॉडल द्वारा समर्थित role और content संरचना ही भेजें।

OpenAI-संगत अनुरोधों में system, user और assistant संदेश क्रम से string content वाली प्रविष्टियों के रूप में भेजें।
Claude Messages में समर्थित system निर्देश और user/assistant के क्रमबद्ध संदेश प्रोटोकॉल के अपने fields में भेजें।
केवल आवश्यक बातचीत का संदर्भ रखें और चुने मॉडल की context सीमाओं का पालन करें।

response = client.messages.create(
    model="Astra 6",
    max_tokens=512,
    system="Answer in clear, concise German.",
    messages=[
        {"role": "user", "content": "What is an API?"},
        {"role": "assistant", "content": "An API lets software exchange requests and responses."},
        {"role": "user", "content": "Give a practical example."},
    ],
)
for block in response.content:
    if block.type == "text":
        print(block.text)

JSON उत्तर माँगें

अनुप्रयोग को तय ढाँचे में उत्तर चाहिए तो उसका उपयोग करने से पहले उसे अपने नियमों के अनुसार जाँचें।

चुने गए प्रोटोकॉल और upstream मॉडल में उपलब्ध संरचित उत्तर के controls का उपयोग करें।
बनाए गए JSON को अविश्वसनीय input मानें: उसे parse करें, आवश्यक fields और types जाँचें तथा अमान्य उत्तर सँभालें।
मॉडल का दस्तावेज़ पुष्टि न करे तो यह न मानें कि उस मॉडल और प्रोटोकॉल में JSON mode उपलब्ध है।

import json

# JSON is generated content, not trusted application input.
response = client.messages.create(
    model="Astra 6", max_tokens=256,
    messages=[{"role": "user", "content": 'Return only JSON with a string field named "summary". Explain an API in one sentence.'}],
)
text = "".join(block.text for block in response.content if block.type == "text")
try:
    result = json.loads(text)
    if not isinstance(result, dict) or not isinstance(result.get("summary"), str):
        raise ValueError("Unexpected response schema")
    print(result["summary"])
except (json.JSONDecodeError, ValueError) as error:
    print("Handle invalid model output:", error)

वास्तविक समय में SSE output पाएँ

Streaming का व्यवहार चुने गए प्रोटोकॉल और upstream मॉडल पर निर्भर है; सामान्य JSON उत्तर stream नहीं होता।

OpenAI-संगत chat फिलहाल समकालिक text लौटाता है और streaming नहीं देता।
Claude Messages में चुना upstream मॉडल समर्थन करे तो stream mode उपयोग करें; proxy मूल server-sent events आगे भेजता है।
Events को आते ही पढ़ें, पूरा होने या त्रुटि पर ठीक से रुकें और अधूरे output को पूरा उत्तर न मानें।

# client is the Anthropic client configured above.
with client.messages.stream(
    model="Astra 6", max_tokens=512,
    messages=[{"role": "user", "content": "Explain API authentication."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final_message = stream.get_final_message()
print("\nStop reason:", final_message.stop_reason)

Tools, content blocks और त्रुटियाँ संभालें

प्रोटोकॉल की मूल संरचनाएँ बनाए रखें और tool calls, बहुरूपी content तथा विफलताओं के लिए अनुप्रयोग का व्यवहार स्पष्ट रखें।

OpenAI-संगत chat फिलहाल tool calls या गैर-text content blocks, दोनों में से किसी का समर्थन नहीं करता।
चुना upstream मॉडल समर्थन करे तो Claude मूल content blocks और tool-use/result डेटा बनाए रखता है; चलाने से पहले tool के नाम और arguments जाँचें।
HTTP status और response body जाँचें, प्रमाणीकरण, अनुमति, validation और rate-limit त्रुटियों में अंतर करें, और अस्थायी त्रुटियों पर बढ़ते अंतराल के साथ फिर प्रयास करें।

import json
from datetime import datetime, timezone
from anthropic import APIError

messages = [{"role": "user", "content": "What time is it in UTC?"}]
tools = [{
    "name": "current_utc_time", "description": "Read the current UTC time.",
    "input_schema": {"type": "object", "properties": {}, "additionalProperties": False},
}]
try:
    reply = client.messages.create(model="Astra 6", max_tokens=256, messages=messages, tools=tools)
    results = []
    for block in reply.content:
        if block.type == "tool_use":
            if block.name != "current_utc_time" or block.input != {}:
                raise ValueError("Unapproved tool request")
            results.append({"type": "tool_result", "tool_use_id": block.id,
                            "content": json.dumps({"utc": datetime.now(timezone.utc).isoformat()})})
    if results:
        messages.append({"role": "assistant", "content": reply.content})
        messages.append({"role": "user", "content": results})
        reply = client.messages.create(model="Astra 6", max_tokens=256, messages=messages, tools=tools)
    print("".join(block.text for block in reply.content if block.type == "text"))
except APIError as error:
    # Log status only; never log keys or private prompts.
    print("API request failed:", getattr(error, "status_code", None))

अक्सर पूछे जाने वाले प्रश्न

क्या अनुरोध में मॉडल का दिखने वाला नाम दे सकता हूँ?

मॉडल से उत्तर पाने के लिए प्रकाशित सटीक पहचानकर्ता ही दें। दिखने वाला नाम routing value नहीं है; जो ID प्रकाशित नहीं है उसका अनुमान कभी न लगाएँ।

ग्राहक कुंजी सर्वर की किस setting में रखूँ?

दोनों प्रोटोकॉल के लिए FUSIONPOINTAI_API_KEY का उपयोग करें। इसका मान विश्वसनीय सर्वर पर रखें; client-side code या लॉग में नहीं।

OpenAI क्लाइंट के लिए कौन-सा URL रखें?

निर्धारित ग्राहक API आधार URL उपयोग करें; इसका डिफ़ॉल्ट https://fusionpointai.com/api/v1 है। Chat Completions endpoint में इसके बाद /chat/completions जुड़ता है।

Claude SDK का आधार URL cURL से अलग क्यों है?

Anthropic SDK अंत में /v1/messages जोड़ता है, इसलिए उसका आधार URL https://fusionpointai.com/api रखें। सीधे HTTP अनुरोध में पूरा /api/v1/messages URL दें।

क्या OpenAI-संगत chat streaming या tools देता है?

नहीं। मौजूदा endpoint केवल समकालिक text संदेश देता है; वहाँ streaming और tool calls उपलब्ध नहीं हैं।

क्या सभी Claude मॉडल में blocks, tools या streaming उपलब्ध हैं?

नहीं। चुना upstream मॉडल समर्थन करे तभी ये मूल सुविधाएँ आगे भेजी जाती हैं। उस मॉडल की क्षमताएँ जाँचें और असमर्थित अनुरोधों को संभालें।

Claude Messages · `POST /messages`

Claude Messages अनुरोध POST /api/v1/messages पर भेजें। ग्राहक कुंजी x-api-key में दें और anthropic-version को 2023-06-01 पर सेट करें। Anthropic SDK का आधार URL https://fusionpointai.com/api रखें, क्योंकि SDK अंत में /v1/messages जोड़ता है; Bearer प्रमाणीकरण भी समर्थित है।

चुने गए upstream मॉडल के समर्थन पर Claude Messages proxy मूल content blocks, tool डेटा और वास्तविक server-sent event streaming को जस का तस आगे भेजता है।

फ़ील्ड	प्रकार	अनिवार्य	सीमाएँ
`model`	`string`	हाँ	`{"minLength":1,"maxLength":160}`
`max_tokens`	`integer`	हाँ	`{"minimum":1,"maximum":100000}`
`messages`	`array`	हाँ	`{"minItems":1,"maxItems":100,"items":{"type":"object","required":["role","content"],"properties":{"role":{"type":"string","enum":["user","assistant"]},"content":{"oneOf":[{"type":"string"},{"type":"array","items":{"type":"object","required":["type"],"properties":{"type":{"type":"string","maxLength":80}},"additionalProperties":true}}]}}}}`
`system`	`string \| array`	नहीं	`{"oneOf":[{"type":"string"},{"type":"array","items":{"type":"object","required":["type","text"],"properties":{"type":{"const":"text"},"text":{"type":"string"}},"additionalProperties":true}}]}`
`stream`	`boolean`	नहीं	`{"default":false}`
`temperature`	`number`	नहीं	`{"minimum":0,"maximum":1}`
`top_p`	`number`	नहीं	`{"minimum":0,"maximum":1}`
`top_k`	`integer`	नहीं	`{"minimum":0,"maximum":100000}`
`stop_sequences`	`array`	नहीं	`{"items":{"type":"string"}}`
`tools`	`array`	नहीं	`{"items":{"type":"object","additionalProperties":true}}`
`tool_choice`	`object`	नहीं	`{"additionalProperties":true}`
`thinking`	`object`	नहीं	`{"additionalProperties":true}`
`metadata`	`object`	नहीं	`{"additionalProperties":true}`
`output_config`	`object`	नहीं	`{"additionalProperties":true}`
`service_tier`	`string`	नहीं	`[]`

{
    "id": "msg_example",
    "type": "message",
    "role": "assistant",
    "model": "Astra 6",
    "content": [
        {
            "type": "text",
            "text": "A concise answer to the supplied question."
        }
    ],
    "stop_reason": "end_turn",
    "stop_sequence": null,
    "usage": {
        "input_tokens": 12,
        "output_tokens": 10
    }
}

{"type":"error","error":{"type":"authentication_error","message":"Invalid or missing API key."}}

SDK से तुरंत शुरुआत

संगत Python या Node.js क्लाइंट के साथ उत्पादन base URL इस्तेमाल करें, या cURL से वही JSON अनुरोध भेजें।

API base URL: https://fusionpointai.com/api/v1

Authorization: Bearer header में ग्राहक API कुंजी भेजें। कुंजी में ai:inference scope और सेवा के लिए खाते की पहुँच होनी चाहिए। कुंजी भरोसेमंद सर्वर पर रखें।

# Install the client for your application language.
# Python:
python -m pip install openai
# Node.js:
npm install openai

# Bash: enter the key without storing it in shell history.
read -rs -p 'FusionPointAI API key: ' FUSIONPOINTAI_API_KEY
export FUSIONPOINTAI_API_KEY
printf '\n'
# After finishing:
# unset FUSIONPOINTAI_API_KEY

curl 'https://fusionpointai.com/api/v1/chat/completions' \
  -H "Authorization: Bearer $FUSIONPOINTAI_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "Jurassic-2",
    "messages": [
        {
            "role": "user",
            "content": "Summarize this in one sentence."
        }
    ],
    "temperature": 0.7,
    "max_tokens": 300
}'

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["FUSIONPOINTAI_API_KEY"],
    base_url="https://fusionpointai.com/api/v1",
)

response = client.chat.completions.create(
    model="Jurassic-2",
    messages=[{"role": "user", "content": "Summarize this in one sentence."}],
    temperature=0.7,
    max_tokens=300,
)
print(response.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.FUSIONPOINTAI_API_KEY,
  baseURL: "https://fusionpointai.com/api/v1",
});

const response = await client.chat.completions.create({
  model: "Jurassic-2",
  messages: [{ role: "user", content: "Summarize this in one sentence." }],
  temperature: 0.7,
  max_tokens: 300,
});
console.log(response.choices[0].message.content);

OpenAI · अनुरोध फ़ील्ड

मॉडल मान inference के लिए मौजूदा समय में प्रकाशित सटीक पंजीकृत पहचानकर्ता हैं। कोई पहचानकर्ता प्रकाशित न हो तो अनुरोध भेजने से पहले प्रदाता कैटलॉग देखें।

फ़ील्ड	प्रकार	अनिवार्य	सीमाएँ
`model`	`string`	हाँ	अधिकतम 160 वर्ण; प्रकाशित सटीक पहचानकर्ता इस्तेमाल करें।
`messages`	`array`	हाँ	क्रम से भेजे जाने वाले 1 से 100 संदेश।
`messages[].role`	`string`	हाँ	system, user या assistant।
`messages[].content`	`string`	हाँ	हर संदेश में अधिकतम 100,000 वर्ण।
`temperature`	`number`	नहीं	0 से 2 तक।
`max_tokens`	`integer`	नहीं	1 से 100,000 तक; मॉडल इससे कम सीमा लगा सकता है।

सफल उत्तर

सफल JSON उत्तर में id, object (chat.completion), created, model और choices होते हैं। हर choice में index, assistant message और finish_reason शामिल होते हैं। Token usage भी लौटाया जा सकता है।

{
    "id": "chatcmpl_example",
    "object": "chat.completion",
    "created": 1700000000,
    "model": "Jurassic-2",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "A concise summary of the supplied text."
            },
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 12,
        "completion_tokens": 10,
        "total_tokens": 22
    }
}

फ़ील्ड	प्रकार	अर्थ
`id`	`string`	Completion का अद्वितीय पहचानकर्ता।
`object`	`string`	उत्तर का प्रकार: chat.completion।
`created`	`integer`	Unix timestamp के रूप में निर्माण का समय।
`model`	`string`	Completion के लिए इस्तेमाल किया गया मॉडल पहचानकर्ता।
`choices`	`array`	Assistant संदेश और समाप्ति कारण वाले completion विकल्प।
`usage`	`object`	लौटाए जाने पर token की गिनती।

अनुरोध सीमाएँ और त्रुटियाँ

लाइव ग्राहक सदस्यताओं में अनुरोध या token उपयोग को कोटा के विरुद्ध नहीं गिना जाता; sandbox कुंजियों पर उनकी प्रकाशित मासिक सीमा लागू होती है। मॉडल की context window, output सीमाएँ और अस्थायी traffic नियंत्रण फिर भी लागू रहते हैं। Chat Completions समकालिक text देता है; Claude Messages समर्थित मूल content blocks, tools और SSE बनाए रखता है। अनुरोध भेजने से पहले दोनों के अलग-अलग operation schemas जाँचें।

chat ऑपरेशन सत्यापन और प्रदाता विफलताओं को error object में लौटाता है। प्रमाणीकरण और scope middleware इसके बजाय सबसे ऊपरी स्तर पर message फ़ील्ड लौटा सकते हैं; उत्तर का status और envelope इस पर निर्भर करता है कि किस स्तर ने अनुरोध अस्वीकार किया।

HTTP स्थिति	अर्थ
`200`	Completion सफलतापूर्वक बनाया गया।
`400`	अनुरोध की body या पैरामीटर अमान्य है।
`401`	Bearer API कुंजी नहीं दी गई या अमान्य है।
`403`	ज़रूरी key scope या खाते की पहुँच उपलब्ध नहीं है।
`429`	एप्लिकेशन अनुरोध सीमा या अस्थायी upstream ट्रैफ़िक नियंत्रण लागू हुआ; अंतराल बढ़ाकर retry करें।
`500`	सेवा उपयोग योग्य completion नहीं लौटा सकी।