నాలెడ్జ్ బేస్ / డెవలపర్లు

చాట్, ప్రతిస్పందనలు మరియు సందేశాలు

ఒక నమూనాను ఏదైనా అడగడానికి మూడు మార్గాలు, క్లయింట్లు ఇప్పటికే మాట్లాడే మూడు ఫార్మాట్లలో, అన్నీ ఒకే నమూనాలపై నడుస్తాయి మరియు ఒకే విధంగా బిల్లు చేయబడతాయి.

ఈ పేజీ సౌలభ్యం కోసం యంత్రంతో అనువదించబడింది. ఆంగ్ల అసలైనది వర్తించే సంస్కరణ.

చాట్ ముగింపులు

OpenAI చాట్ ఫార్మాట్, మరియు దాదాపు ప్రతి సాధనం దీనిని సపోర్ట్ చేస్తుంది. ఇప్పటివరకు జరిగిన సంభాషణను పంపండి మరియు తదుపరి సందేశాన్ని తిరిగి పొందండి.

POST https://nymbot.ai/api/v1/chat/completions - ఒక API కీ అవసరం.

మాత్రమే model మరియు messages అవసరం ఉంది. ఎంచుకున్న మోడల్ తీసుకోని శాంప్లింగ్ పరామితి లోపం లేకుండా తొలగించబడుతుంది, కాబట్టి ఒక అభ్యర్థన బాడీ నమూనాల అంతటా పనిచేస్తుంది. మోడల్ జాబితా ప్రతి మోడల్ యొక్క నమూనాలను ఇస్తుంది. supported_parametersవదిలివేయబడటానికి బదులుగా తిరస్కరించబడేది ఏమిటంటే, మోడల్ అసలు చేయలేని ఏ పనైనా: చూడలేని మోడల్‌కు చిత్రాలు, వాటిని పిలవలేకపోయిన మోడల్‌కు సాధనాలు.

సమాధానం ఒక సాధారణమైనది chat.completion, ఖర్చుతో usage.cost (డాలర్లలో) మరియు nymbot వస్తువు. model పరిష్కరించబడిన మోడల్ ఐడి, కాబట్టి ఒక చిన్న పేరు పూర్తి పేరుగా తిరిగి వస్తుంది. సమాధానం ఇచ్చే ముందు మోడల్ తర్కించినట్లయితే, దాని తర్కం దీనిలో ఉంటుంది message.reasoning_content, సమాధానం నుండి వేరుగా ఉంటుంది.

ప్రతిస్పందన

{
  "id": "chatcmpl-5f1c0a9e27d84b3c",
  "object": "chat.completion",
  "created": 1790726400,
  "model": "anthropic/claude-sonnet-5",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "A Lightning invoice is a one-time payment request..."
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 1240,
    "completion_tokens": 380,
    "total_tokens": 1620,
    "prompt_tokens_details": { "cached_tokens": 0 },
    "completion_tokens_details": { "reasoning_tokens": 0 },
    "cost": 0.01895
  },
  "nymbot": {
    "balance": "pro",
    "charged_credits": 0.162,
    "charged_sats": 16.2,
    "balance_credits": 412.425,
    "balance_sats": 41242.5
  }
}

finish_reason ఇది తిరిగి వచ్చిన దాని నుండి లెక్కించబడింది, ఎందుకంటే ప్రొవైడర్లు దానిని భిన్నంగా నివేదిస్తారు: tool_calls మోడల్ సాధనాలను అడిగినప్పుడు, length సమాధానం అనుమతించిన ప్రతి టోకెన్ను ఉపయోగించినప్పుడు (లేదా మోడల్ వాటిని అన్ని తార్కికంగా ఖర్చు చేసి, సమాధానం వ్రాయలేదు), content_filter ప్రదాత నిరాకరించినప్పుడు, మరియు stop లేకపోతే. usage.completion_tokens_details.reasoning_tokens ఎల్లప్పుడూ 0: దాచబడింది రీజనింగ్ టోకెన్‌లు లెక్కించబడతాయి, మరియు ఛార్జ్ చేయబడతాయి, లో completion_tokens.

ప్రతి ఎండ్ పాయింట్ షేర్ల స్థితి సంకేతాలు క్రింద జాబితా చేయబడ్డాయి లోపాలు.

cURL

curl https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "messages": [
      {"role": "system", "content": "Answer in one short paragraph."},
      {"role": "user", "content": "What is a Lightning invoice?"}
    ],
    "max_tokens": 400
  }'

Python

import os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

reply = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    messages=[
        {"role": "system", "content": "Answer in one short paragraph."},
        {"role": "user", "content": "What is a Lightning invoice?"},
    ],
    max_tokens=400,
)
print(reply.choices[0].message.content)
print(reply.usage.cost)

JavaScript

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://nymbot.ai/api/v1", apiKey: process.env.NYMBOT_API_KEY });

const reply = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-5",
  messages: [
    { role: "system", content: "Answer in one short paragraph." },
    { role: "user", content: "What is a Lightning invoice?" },
  ],
  max_tokens: 400,
});
console.log(reply.choices[0].message.content);
console.log(reply.usage.cost);

స్ట్రీమింగ్

తో. "stream": true సమాధానం సర్వర్-పంపిన సంఘటనలుగా వస్తుంది, మోడల్ దానిని వ్రాస్తుంది. ప్రతి సంఘటన ఒక chat.completion.chunk ఎ లో data: లైన్, మరియు ప్రవాహం ముగుస్తుంది data: [DONE]. రీజనింగ్ వస్తుంది delta.reasoning_content, సమాధానం delta.content.

సుదీర్ఘమైన సమాధానం లేదా పెద్దది వంటి, సుమారు 100 సెకన్ల కంటే ఎక్కువ సమయం పట్టే దేన్నైనా స్ట్రీమ్ చేయండి max_tokens లేదా ఒక రీజనింగ్ మోడల్. స్ట్రీమ్ చేయబడని అభ్యర్థన సమాధానం పూర్తయ్యే వరకు ఏమీ పంపదు, మరియు మీ మధ్య మరియు Nymbot మధ్య నెట్‌వర్క్ సుమారు 100 సెకన్ల తర్వాత ఖాళీగా ఉన్న కనెక్షన్‌ను మూసివేయవచ్చు; మోడల్ తన పనిని పూర్తి చేస్తుంది మరియు అది రాసిన దానికి ఛార్జీ వసూలు చేయబడుతుంది, కానీ సమాధానం కోల్పో wird. ఒక స్ట్రీమ్ కీప్-అలైవ్స్‌ను పంపుతుంది, కాబట్టి మోడల్ రాసేంత సేపు అది తెరిచి ఉంటుంది.

ప్రవాహం.

data: {"id":"chatcmpl-5f1c0a9e27d84b3c","object":"chat.completion.chunk","created":1790726400,"model":"anthropic/claude-sonnet-5","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}

data: {"id":"chatcmpl-5f1c0a9e27d84b3c","object":"chat.completion.chunk","created":1790726400,"model":"anthropic/claude-sonnet-5","choices":[{"index":0,"delta":{"content":"A Lightning invoice"},"finish_reason":null}]}

: keep-alive

data: {"id":"chatcmpl-5f1c0a9e27d84b3c","object":"chat.completion.chunk","created":1790726400,"model":"anthropic/claude-sonnet-5","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: {"id":"chatcmpl-5f1c0a9e27d84b3c","object":"chat.completion.chunk","created":1790726400,"model":"anthropic/claude-sonnet-5","choices":[],"usage":{"prompt_tokens":1240,"completion_tokens":380,"total_tokens":1620,"cost":0.01895},"nymbot":{"balance":"pro","charged_credits":0.162,"charged_sats":16.2,"balance_credits":412.425,"balance_sats":41242.5}}

data: [DONE]

• దీనితో ప్రారంభమయ్యే పంక్తులు : మోడల్ ఆలోచిస్తున్నప్పుడు ప్రతి 15 సెకన్లకు పంపబడే కీప్-అలైవ్ కామెంట్లు. SSE క్లయింట్లు వాటిని దాటవేస్తారు.
• అడగండి. "stream_options": {"include_usage": true} పైన పేర్కొన్న చివరి భాగాన్ని పొందడానికి, ఒక ఖాళీ భాగంతో choices, టోకెన్ గణనలు, ఖర్చు మరియు nymbot వస్తువు.
• స్ట్రీమ్ ముగిసిన తర్వాత ఛార్జీ సెటిల్ అవుతుంది. మీరు కనెక్షన్‌ను త్వరగా మూసివేస్తే, మోడల్ ఆగదు: Nymbot దాని టోకెన్ కౌంట్‌ను తెలుసుకోవడానికి, ప్రొవైడర్ యొక్క స్ట్రీమ్‌లోని మిగిలిన భాగాన్ని గరిష్టంగా 25 సెకన్ల వరకు చదువుతుంది, మరియు ప్రొవైడర్ నివేదించిన దానిని మీరు చెల్లిస్తారు. ఆ కౌంట్ లేకపోతే, మీ ఇన్‌పుట్ మరియు వ్రాయబడిన దాని నుండి, అలాగే రీజనింగ్ చేసే మోడల్ యొక్క మొత్తం అవుట్‌పుట్ అలవెన్స్‌ను బట్టి ఛార్జీ అంచనా వేయబడుతుంది.
• మొదటి భాగానికి ముందు ఉన్న లోపం, 401 లేదా 402, దాని స్థితి కోడ్తో సాధారణ JSONగా తిరిగి వస్తుంది, స్ట్రీమ్గా కాదు. స్ట్రీమ్ ప్రారంభమైన తర్వాత ఒక లోపం చివరిగా వస్తుంది data: {"error": {…}} ఈవెంట్, మరియు స్ట్రీమ్ లేకుండా ముగుస్తుంది [DONE].
• సాధనాలతో అభ్యర్థనలు, మరియు ఓపెన్ఏఐ యొక్క ప్రతిస్పందనల రవాణాపై నమూనాలు, ప్రొవైడర్ నుండి ప్రసారం చేయబడవు. సమాధానం పూర్తయిన తర్వాత పంపిన చెల్లుబాటు అయ్యే ప్రవాహంతో వారు సమాధానం ఇస్తారు.

cURL

curl -N https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nymbot/auto",
    "stream": true,
    "stream_options": {"include_usage": true},
    "messages": [{"role": "user", "content": "Write a haiku about sats."}]
  }'

Python

import os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

stream = client.chat.completions.create(
    model="nymbot/auto",
    stream=True,
    stream_options={"include_usage": True},
    messages=[{"role": "user", "content": "Write a haiku about sats."}],
)
for chunk in stream:
    if chunk.choices:
        print(chunk.choices[0].delta.content or "", end="", flush=True)
    elif chunk.usage:
        print("\ncost:", chunk.usage.cost)

JavaScript

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://nymbot.ai/api/v1", apiKey: process.env.NYMBOT_API_KEY });

const stream = await client.chat.completions.create({
  model: "nymbot/auto",
  stream: true,
  stream_options: { include_usage: true },
  messages: [{ role: "user", content: "Write a haiku about sats." }],
});
for await (const chunk of stream) {
  if (chunk.choices.length) process.stdout.write(chunk.choices[0].delta.content || "");
  else if (chunk.usage) console.log("\ncost:", chunk.usage.cost);
}

టూల్ కాల్స్

ఫంక్షన్లను వివరించండి tools మరియు మోడల్ సమాధానం ఇవ్వడానికి బదులుగా ఒకదాన్ని కాల్ చేయమని అడగవచ్చు. మీరు ఫంక్షన్ను అమలు చేస్తారు, దాని ఫలితాన్ని ఒక విధంగా జోడించండి tool అదే సందేశం tool_call_id, మరియు సంభాషణను మళ్ళీ పంపండి. నింబోట్ మీ విధులను ఎన్నటికీ అమలు చేయదు; ఇది నమూనా యొక్క అభ్యర్థనను మీకు తిరిగి పంపుతుంది.

tool_choice తీసుకుంటారు. "auto", "none", "required" లేదా {"type": "function", "function": {"name": "…"}}నమూనా జాబితా ఏ నమూనాలు సాధనాలను పిలవగలవో సూచిస్తుంది (capabilities.tools). సాధనాలు తిరస్కరించబడ్డాయి 400 unsupported_tool మీద nymbot/auto మరియు ఓపెన్ఏఐ యొక్క ప్రతిస్పందనల రవాణాపై నడిచే కొన్ని కేటలాగ్ నమూనాలపై, నింబోట్ సాధనాలను పంపించలేము.

తో. "stream": trueసాధనాలతో కూడిన అభ్యర్థన ఒక ముక్కలో నడుస్తుంది, ఆపై సాధారణ భాగం క్రమం వలె పంపబడుతుందిః రోల్, ప్రతి సాధనం కాల్ను దాని సూచిక, ఐడి, పేరు మరియు వాదనలు మరియు ముగింపు భాగంతో కలిగి ఉన్న ఒక భాగం. ప్రసారం చేయబడిన సాధనం కాల్స్ను చదివే క్లయింట్లు దానిని ఎప్పటిలాగే నిర్వహిస్తారు.

ప్రతిస్పందన, పాక్షికంగా

"choices": [
  {
    "index": 0,
    "message": {
      "role": "assistant",
      "content": null,
      "tool_calls": [
        {
          "id": "call_7d2e",
          "type": "function",
          "function": { "name": "get_invoice_status", "arguments": "{\"invoice_id\":\"a41f\"}" }
        }
      ]
    },
    "finish_reason": "tool_calls"
  }
]

cURL

curl https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "messages": [{"role": "user", "content": "Has invoice a41f been paid?"}],
    "tools": [{
      "type": "function",
      "function": {
        "name": "get_invoice_status",
        "description": "Look up whether an invoice is paid.",
        "parameters": {
          "type": "object",
          "properties": {"invoice_id": {"type": "string"}},
          "required": ["invoice_id"]
        }
      }
    }]
  }'

Python

import json, os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "get_invoice_status",
        "description": "Look up whether an invoice is paid.",
        "parameters": {
            "type": "object",
            "properties": {"invoice_id": {"type": "string"}},
            "required": ["invoice_id"],
        },
    },
}]
messages = [{"role": "user", "content": "Has invoice a41f been paid?"}]

reply = client.chat.completions.create(model="anthropic/claude-sonnet-5", messages=messages, tools=tools)
call = reply.choices[0].message.tool_calls[0]
args = json.loads(call.function.arguments)

messages.append(reply.choices[0].message)
messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps({"paid": True})})

final = client.chat.completions.create(model="anthropic/claude-sonnet-5", messages=messages, tools=tools)
print(final.choices[0].message.content)

JavaScript

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://nymbot.ai/api/v1", apiKey: process.env.NYMBOT_API_KEY });

const tools = [{
  type: "function",
  function: {
    name: "get_invoice_status",
    description: "Look up whether an invoice is paid.",
    parameters: {
      type: "object",
      properties: { invoice_id: { type: "string" } },
      required: ["invoice_id"],
    },
  },
}];
const messages = [{ role: "user", content: "Has invoice a41f been paid?" }];

const reply = await client.chat.completions.create({ model: "anthropic/claude-sonnet-5", messages, tools });
const call = reply.choices[0].message.tool_calls[0];
const args = JSON.parse(call.function.arguments);

messages.push(reply.choices[0].message);
messages.push({ role: "tool", tool_call_id: call.id, content: JSON.stringify({ paid: true }) });

const final = await client.chat.completions.create({ model: "anthropic/claude-sonnet-5", messages, tools });
console.log(final.choices[0].message.content);

అభ్యర్థనలోని చిత్రాలు

తో నమూనాలు capabilities.vision చిత్రాలను చదవగలరు. ఒకదాన్ని జోడించండి image_url వినియోగదారు సందేశానికి ఒక భాగం, ఒక పబ్లిక్ సందేశంతో https:// లింక్ లేదా a data:image/…;base64, URL. ప్రతి అభ్యర్థనకు 20 చిత్రాల వరకు. SVG చిత్రాలు తిరస్కరించబడతాయి, అలాగే 4,096 అక్షరాలకు పైగా ఉన్న లింక్ లేదా అందులో వినియోగదారు పేరు లేదా పాస్వర్డ్ ఉన్న లింక్ (400 invalid_image_url). ఒక ఐచ్ఛికం detail అనేది auto, low లేదా high.

తో. nymbot/autoదీనిలో ఒక చిత్రంతో అభ్యర్థన చూడగలిగే ప్రామాణిక నమూనాకు పంపబడుతుంది. జాబితా లేని నమూనా capabilities.vision వారితో చిత్రాలు తీయడానికి నిరాకరించారు 400 unsupported_contentచిత్రాలు వినియోగదారు సందేశాలలో మాత్రమే ఉండవచ్చు. ఒక లింక్ తప్పనిసరిగా పబ్లిక్ హోస్ట్ను సూచించాలి; నిమ్బోట్ చిత్రాన్ని మోడల్ ప్రొవైడర్కు పంపుతుంది మరియు దానిని ఉంచదు.

మిగిలిన అభ్యర్థనల మాదిరిగానే ప్రొవైడర్ దాని కోసం లెక్కించే ఇన్పుట్ టోకెన్లుగా ఒక చిత్రం ఛార్జ్ చేయబడుతుంది.

cURL

curl https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "messages": [{
      "role": "user",
      "content": [
        {"type": "text", "text": "What is in this picture?"},
        {"type": "image_url", "image_url": {"url": "https://example.com/receipt.jpg"}}
      ]
    }]
  }'

Python

import base64, os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

with open("receipt.jpg", "rb") as f:
    data_url = "data:image/jpeg;base64," + base64.b64encode(f.read()).decode()

reply = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What is in this picture?"},
            {"type": "image_url", "image_url": {"url": data_url}},
        ],
    }],
)
print(reply.choices[0].message.content)

JavaScript

import { readFile } from "node:fs/promises";
import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://nymbot.ai/api/v1", apiKey: process.env.NYMBOT_API_KEY });

const dataUrl = "data:image/jpeg;base64," + (await readFile("receipt.jpg")).toString("base64");

const reply = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-5",
  messages: [{
    role: "user",
    content: [
      { type: "text", text: "What is in this picture?" },
      { type: "image_url", image_url: { url: dataUrl } },
    ],
  }],
});
console.log(reply.choices[0].message.content);

తర్కం

తో నమూనాలు capabilities.reasoning వారు సమాధానం చెప్పే ముందు ఆలోచించవచ్చు. దాని గురించి ఎక్కువ లేదా తక్కువ అడగండి reasoning_effort ("minimal", "low", "medium" లేదా "high") లేదా "reasoning": {"effort": "high"}, లేదా జోడించండి :thinking మోడల్ పేరుకు, అంటే అధిక ప్రయత్నం. తర్కం లేకుండా ఒక మోడల్ మీద సెట్టింగ్ విస్మరించబడుతుంది. nymbot/auto, :thinking అభ్యర్థనను ప్రామాణిక తార్కిక మార్గానికి పంపుతుంది.

ఆంత్రోపిక్ నమూనాలపై ప్రయత్నం సుమారు 1,000,2,000,8,000 లేదా 16,000 టోకెన్ల ఆలోచనా బడ్జెట్గా మారుతుంది, ఎప్పుడూ అంతకంటే ఎక్కువ కాదు. max_tokens అనుమతిస్తుంది. ఆలోచించడం ఆపివేయబడుతుంది tool_choice ఒక సాధనాన్ని బలవంతం చేస్తుంది, మరియు అభ్యర్థన సాధన లూప్ని కొనసాగించినప్పుడు (దాని చివరి సందేశం సాధన ఫలితం), ఎందుకంటే ఆంథ్రోపిక్ దానిని తిరిగి ప్రారంభించడానికి మునుపటి సంతకం చేసిన ఆలోచన అవసరం. ప్రతిస్పందనలు మరియు సందేశాల ముగింపు పాయింట్లకు కూడా ఇది వర్తిస్తుంది.

తర్కం తిరిగి వస్తుంది message.reasoning_content, లేదా delta.reasoning_content ప్రసారం చేసేటప్పుడు, సమాధానంలో ఎప్పుడూ కలపవద్దు. రీజనింగ్ అవుట్పుట్ మరియు లోపల ఛార్జ్ చేయబడుతుంది completion_tokensకొంతమంది ప్రొవైడర్లు రీజనింగ్ టెక్స్ట్ను అస్సలు తిరిగి ఇవ్వరు, మరియు అది ఇప్పటికీ ఛార్జ్ చేయబడుతుంది.

cURL

curl https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "reasoning_effort": "high",
    "messages": [{"role": "user", "content": "Is 2^61 - 1 prime? Show why."}]
  }'

Python

import os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

reply = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    reasoning_effort="high",
    messages=[{"role": "user", "content": "Is 2^61 - 1 prime? Show why."}],
)
message = reply.choices[0].message
print(getattr(message, "reasoning_content", None))
print(message.content)

JavaScript

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://nymbot.ai/api/v1", apiKey: process.env.NYMBOT_API_KEY });

const reply = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-5",
  reasoning_effort: "high",
  messages: [{ role: "user", content: "Is 2^61 - 1 prime? Show why." }],
});
console.log(reply.choices[0].message.reasoning_content);
console.log(reply.choices[0].message.content);

నమూనా ప్రత్యయాలు

నమూనా పేరుపై ఒక ప్రత్యయం మరొక ఫీల్డ్ లేకుండా అభ్యర్థనను ఎలా నిర్వహిస్తుందో మారుస్తుంది. అవి పూర్తి ఐడి మరియు చిన్న పేర్లపై ఒకే విధంగా పనిచేస్తాయి. anthropic/claude-sonnet-5:online.

ఏదైనా ఇతర ప్రత్యయం విస్మరించబడుతుంది. మొత్తం పేరు మొదట ప్రయత్నించబడుతుంది, కాబట్టి ఐడి నిజంగా కోలన్ను కలిగి ఉన్న మోడల్ ఇప్పటికీ పనిచేస్తుంది; అలా చేయకపోతే, ఒక మోడల్ సరిపోలేంత వరకు ప్రత్యయాలు ఒక సమయంలో చివర నుండి తీసివేయబడతాయి. ఒక మోడల్ పేరు గరిష్టంగా 4 ప్రత్యయాలతో 200 అక్షరాల పొడవు ఉండవచ్చు; పొడవైనది తో తిరస్కరించబడుతుంది 400 invalid_value.

cURL

curl https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5:thinking",
    "messages": [{"role": "user", "content": "Plan a three-day trip to Lisbon."}]
  }'

Python

import os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

reply = client.chat.completions.create(
    model="anthropic/claude-sonnet-5:thinking",
    messages=[{"role": "user", "content": "Plan a three-day trip to Lisbon."}],
)
print(reply.choices[0].message.content)

JavaScript

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://nymbot.ai/api/v1", apiKey: process.env.NYMBOT_API_KEY });

const reply = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-5:thinking",
  messages: [{ role: "user", content: "Plan a three-day trip to Lisbon." }],
});
console.log(reply.choices[0].message.content);

వెబ్ శోధన

ఏదైనా చాట్ మోడల్ ప్రత్యక్ష వెబ్ నుండి సమాధానం ఇవ్వగలదు. నిమ్బోట్ చివరి వినియోగదారు సందేశం (దాని మొదటి 2,000 అక్షరాలు) కోసం శోధిస్తుంది, ఉత్తమ పేజీలను చదువుతుంది మరియు ప్రశ్నతో నమూనాకు ఇస్తుంది, మోడల్ సూచనలను తీసుకోకూడదని వెలుపలి కంటెంట్గా గుర్తించబడింది. రెండు రీతులు ఉన్నాయిః

• ఎల్లప్పుడూ వెతకండి: "plugins": [{"id": "web", "max_results": 5}], లేదా a :online నమూనాపై ప్రత్యయం.
• అది సహాయపడినప్పుడు వెతకండి: "tools": [{"type": "web_search", "parameters": {"max_results": 5}}], గా కూడా ఆమోదించబడింది web_search_preview లేదా openrouter:web_searchప్రశ్నకు ప్రస్తుత సమాచారం అవసరమని అనిపించినప్పుడు మాత్రమే నిమ్బోట్ శోధిస్తుంది, అదే పరీక్షను యాప్ ఉపయోగిస్తుంది.

max_results డిఫాల్ట్‌గా 5 మరియు గరిష్టంగా 10. మూలాలు ... లో తిరిగి వస్తాయి. nymbot.web_search.sources, ప్రతి ఒక్కరితో title, snippet మరియు url, మరియు url_citation సందేశంపై ఉల్లేఖనాలు.

ప్రతి శోధనకు $0.008 ఖర్చవుతుంది, టోకెన్ల పైన సాట్స్గా మార్చబడుతుంది, మరియు ఇది హోల్డ్లో భాగం. ఇది చదివే పేజీలు కూడా ఇన్పుట్ టోకెన్లు, కాబట్టి వెబ్ నుండి వచ్చే సమాధానం చల్లగా అడిగే అదే ప్రశ్న కంటే ఎక్కువ ఖర్చు అవుతుంది, కొన్నిసార్లు చాలా రెట్లు ఎక్కువ.

ప్రతిస్పందన, పాక్షికంగా

"nymbot": {
  "balance": "pro",
  "charged_credits": 0.431,
  "charged_sats": 43.1,
  "balance_credits": 411.994,
  "balance_sats": 41199.4,
  "web_search": {
    "sources": [
      { "title": "Lightning Network - Wikipedia", "snippet": "The Lightning Network is a payment protocol...", "url": "https://en.wikipedia.org/wiki/Lightning_Network" }
    ]
  }
}

cURL

curl https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "plugins": [{"id": "web", "max_results": 5}],
    "messages": [{"role": "user", "content": "What changed in the latest Bitcoin Core release?"}]
  }'

Python

import os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

reply = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    messages=[{"role": "user", "content": "What changed in the latest Bitcoin Core release?"}],
    extra_body={"plugins": [{"id": "web", "max_results": 5}]},
)
print(reply.choices[0].message.content)
for source in reply.model_extra["nymbot"]["web_search"]["sources"]:
    print(source["url"])

JavaScript

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://nymbot.ai/api/v1", apiKey: process.env.NYMBOT_API_KEY });

const reply = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-5",
  plugins: [{ id: "web", max_results: 5 }],
  messages: [{ role: "user", content: "What changed in the latest Bitcoin Core release?" }],
});
console.log(reply.choices[0].message.content);
for (const source of reply.nymbot.web_search.sources) console.log(source.url);

రెస్పాన్సెస్ API

ఓపెన్ఏఐ ఏజెంట్స్ ఎస్డికె మరియు కోడెక్స్ ఉపయోగించే ఓపెన్ఏఐ యొక్క కొత్త ఫార్మాట్. ఇది చాట్ కంప్లీషన్స్ మాదిరిగానే నమూనాలు, బిల్లింగ్ మరియు లక్షణాలపై నడుస్తుంది.

POST https://nymbot.ai/api/v1/responses - ఒక API కీ అవసరం.

ప్రతిస్పందన

{
  "id": "resp_8c1e4b0f9a2d4e61",
  "object": "response",
  "created_at": 1790726400,
  "status": "completed",
  "model": "anthropic/claude-sonnet-5",
  "output": [
    {
      "type": "message",
      "id": "msg_2b7f",
      "role": "assistant",
      "status": "completed",
      "content": [{ "type": "output_text", "text": "A Lightning invoice is...", "annotations": [] }]
    }
  ],
  "output_text": "A Lightning invoice is...",
  "usage": {
    "input_tokens": 1240,
    "input_tokens_details": { "cached_tokens": 0 },
    "output_tokens": 380,
    "output_tokens_details": { "reasoning_tokens": 0 },
    "total_tokens": 1620
  },
  "incomplete_details": null,
  "error": null,
  "instructions": null,
  "store": false,
  "previous_response_id": null,
  "metadata": {},
  "nymbot": { "balance": "pro", "charged_credits": 0.162, "charged_sats": 16.2, "balance_credits": 412.425, "balance_sats": 41242.5 }
}

ఒక సాధన అభ్యర్థన కనిపిస్తుంది output ఎ గా function_call తో వస్తువు call_id, name మరియు argumentsఫలితాన్ని తిరిగి పంపండి function_call_output అదే వస్తువుతో call_idరీజనింగ్, మోడల్ దానిని తిరిగి ఇచ్చినప్పుడు, ఒక reasoning తో వస్తువు reasoning_text కంటెంట్, మొదట జాబితా చేయబడింది. status అనేది incomplete సమాధానం వచ్చినప్పుడు max_output_tokens లేదా ప్రొవైడర్ నిరాకరించారు, incomplete_details.reason దానికి అమర్చండి max_output_tokens లేదా content_filterప్రతిస్పందన కూడా ఓపెన్ఏఐ మాదిరిగానే అభ్యర్థన యొక్క అమరికలను (ఉష్ణోగ్రత, సాధనాలు, సాధనాల ఎంపిక మొదలైనవి) ప్రతిధ్వనిస్తుంది. nymbot ఖర్చు వస్తువు.

స్ట్రీమ్డ్, ప్రతి ఈవెంట్ ఒక event: లైన్ మరియు a data: ఒక తో లైన్ sequence_number, ఈ క్రమంలోః response.created, response.in_progress, response.output_item.added, response.content_part.added, ఏ సంఖ్యలో అయినా response.output_text.delta, response.output_text.done, response.content_part.done, response.output_item.done, చివరకు response.completed వాడకం మరియు ఖర్చుతో ముగుస్తుంది. జవాబు చిన్నది ఇలా ముగుస్తుంది response.incomplete బదులుగా, మరియు ప్రవాహం ప్రారంభమైన తర్వాత వైఫల్యం response.failedరీజనింగ్ స్ట్రీమ్స్ దాని స్వంత అంశంగా response.reasoning_text.delta మరియు .doneటూల్ కాల్స్ సందేశం తర్వాత వస్తాయి, ప్రతి ఒక్కటి ఒక అంశంగా ఉంటుంది response.function_call_arguments.delta మరియు .done.

cURL

curl https://nymbot.ai/api/v1/responses \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "instructions": "Answer in one short paragraph.",
    "input": "What is a Lightning invoice?"
  }'

Python

import os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

response = client.responses.create(
    model="anthropic/claude-sonnet-5",
    instructions="Answer in one short paragraph.",
    input="What is a Lightning invoice?",
)
print(response.output_text)

JavaScript

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://nymbot.ai/api/v1", apiKey: process.env.NYMBOT_API_KEY });

const response = await client.responses.create({
  model: "anthropic/claude-sonnet-5",
  instructions: "Answer in one short paragraph.",
  input: "What is a Lightning invoice?",
});
console.log(response.output_text);

ఆంత్రోపిక్ మెసేజెస్

ఆంథ్రోపిక్ ఫార్మాట్, ఆంథ్రోపిక్ ఎస్డికెలు మరియు క్లాడ్ కోడ్ కోసం. ఇది కేటలాగ్లోని ప్రతి మోడల్తో పనిచేస్తుంది, క్లాడ్ మాత్రమే కాదుః అభ్యర్థన అనువదించబడింది, అదే పైప్లైన్ ద్వారా అమలు చేయబడుతుంది మరియు తిరిగి అనువదించబడుతుంది.

POST https://nymbot.ai/api/v1/messages - ఒక API కీ అవసరం, x-api-key లేదా Authorization: Bearer.

ది. anthropic-version మరియు anthropic-beta శీర్షికలు ఆమోదించబడతాయి మరియు విస్మరించబడతాయి. ఆంత్రోపిక్ నమూనా పేర్లు కేటలాగ్కు సరిపోలుతాయి, కాబట్టి క్లాడ్ కోడ్ మరియు ఎస్డికెలు వారు ఇప్పటికే ఉపయోగించిన పేర్లతో పనిచేస్తాయిః

• కటలాగ్ కి తెలిసిన పేరు, ఉదాహరణకు claude-sonnet-5 లేదా anthropic/claude-opus-5, ఉన్నట్లుగా ఉపయోగించబడుతుంది.
• లేకపోతే ఒక తేదీ (-20260514), -latest, వంటి ఒక వెర్షన్ ట్యాగ్ -v1, వంటి బ్రాకెట్ ట్యాగ్ [1m] మరియు ఒక anthropic/ లేదా anthropic. ఉపసర్గలు తీసివేయబడతాయి, మరియు సంస్కరణలోని చుక్కలు మరియు డాష్లు రెండు విధాలుగా ప్రయత్నించబడతాయి (claude-haiku-4-5 కనుగొనబడింది claude-haiku-4.5).
• ఒకవేళ అది ఇంకా దేనికీ సరిపోలకపోతే, క్యాటలాగ్ వెర్షన్ అడిగిన దానికంటే సమానంగా లేదా కొత్తదిగా ఉన్నంత వరకు, ఆ కుటుంబం (Opus, Sonnet లేదా Haiku) ఉపయోగించబడుతుంది.
• దేనికీ సరిపోలని పేరు తిరిగి వస్తుంది 404 not_found_error.

ప్రతిస్పందన

{
  "id": "msg_01c7a2f93e5b4d08",
  "type": "message",
  "role": "assistant",
  "model": "anthropic/claude-sonnet-5",
  "content": [{ "type": "text", "text": "A Lightning invoice is..." }],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 1240,
    "output_tokens": 380,
    "cache_read_input_tokens": 0,
    "cache_creation_input_tokens": 0
  },
  "nymbot": { "balance": "pro", "charged_credits": 0.162, "charged_sats": 16.2, "balance_credits": 412.425, "balance_sats": 41242.5 }
}

content కూడా పట్టుకోవచ్చు tool_use బ్లాక్స్ మరియు a thinking బ్లాక్, ఎవరిది signature ఖాళీగా ఉంది. stop_reason అనేది end_turn, max_tokens, tool_use లేదా refusal, అదే విధంగా పనిచేశారు finish_reason మీద చాట్ ముగింపులు; stop_sequence ఎల్లప్పుడూ null, ఒక స్టాప్ సీక్వెన్స్ సమాధానాన్ని ముగించినప్పటికీ. input_tokens తాజా ఇన్పుట్ను మాత్రమే లెక్కిస్తుంది; కాష్ చేయబడిన ఇన్పుట్ రెండు కాష్ ఫీల్డ్లలో ఉంది. ఖర్చు లో ఉంది nymbot వస్తువు మరియు X-Nymbot-Cost-Sats తల.

స్ట్రీమ్డ్, సంఘటనలు ఆంత్రోపిక్ యొక్కః message_start, content_block_start, ping, content_block_delta (text_delta, input_json_delta లేదా thinking_delta), content_block_stop, message_delta ఆగడానికి కారణంతో, వినియోగం మరియు ఆ nymbot ఖర్చు వస్తువు, మరియు message_stop. A ping మోడల్ పని చేస్తున్నప్పుడు ప్రతి 15 సెకన్లకు పంపబడుతుంది. టెక్స్ట్ తర్వాత టూల్ కాల్స్ వస్తాయి, ప్రతి ఒక్కటి tool_use దాని మొత్తం ఇన్పుట్ను ఒకదానిలో బ్లాక్ చేయండి input_json_delta.

ఈ ఎండ్ పాయింట్లోని లోపాలు ఆంత్రోపిక్ యొక్క ఆకృతిని ఉపయోగిస్తాయిః {"type": "error", "error": {"type": "not_found_error", "message": "…"}}ఒక చిన్న సంతులనం 402 billing_error, ఓవర్లోడ్ చేయబడిన ప్రొవైడర్ 503 overloaded_errorస్ట్రీమ్ ప్రారంభమైన తర్వాత విఫలమైతే అది ఒక దానిగా పంపబడుతుంది error ఈవెంట్.

cURL

curl https://nymbot.ai/api/v1/messages \
  -H "x-api-key: $NYMBOT_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "What is a Lightning invoice?"}]
  }'

Python

import os
import anthropic

client = anthropic.Anthropic(base_url="https://nymbot.ai/api", api_key=os.environ["NYMBOT_API_KEY"])

message = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "What is a Lightning invoice?"}],
)
print(message.content[0].text)

JavaScript

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({ baseURL: "https://nymbot.ai/api", apiKey: process.env.NYMBOT_API_KEY });

const message = await client.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "What is a Lightning invoice?" }],
});
console.log(message.content[0].text);

గణన టోకెన్లు

సందేశాల అభ్యర్థన ఎన్ని ఇన్పుట్ టోకెన్లను ఉపయోగిస్తుందనే అంచనా, తద్వారా క్లయింట్ పంపే ముందు తనిఖీ చేయవచ్చు. ఇది ఉచితం, కానీ ఇప్పటికీ ఒక కీ అవసరం.

POST https://nymbot.ai/api/v1/messages/count_tokens - ఒక API కీ అవసరం. ఉచితం.

శరీరం ఒకటే సందేశాలు, లేకుండా max_tokensమోడల్ పేరు పరిష్కరించాల్సి ఉంటుంది. లెక్కింపు అనేది ఒక అంచనాః సిస్టమ్ ప్రాంప్ట్ యొక్క అక్షరాలు, సందేశాలు, సాధన కాల్స్ మరియు సాధన నిర్వచనాలను నాలుగుతో విభజించి, ప్రతి చిత్రానికి 1,600 ప్లస్ చేయండి. ఇది ప్రొవైడర్ యొక్క సొంత టోకనైజర్ కాదు, కాబట్టి నిజమైన లెక్కింపు భిన్నంగా ఉంటుంది. దాని పరిమితికి చేరుకున్న కీ ఇప్పటికీ దానిని ఉపయోగించవచ్చు.

ప్రతిస్పందన

{ "input_tokens": 318 }

cURL

curl https://nymbot.ai/api/v1/messages/count_tokens \
  -H "x-api-key: $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5",
    "messages": [{"role": "user", "content": "What is a Lightning invoice?"}]
  }'

Python

import os
import anthropic

client = anthropic.Anthropic(base_url="https://nymbot.ai/api", api_key=os.environ["NYMBOT_API_KEY"])

count = client.messages.count_tokens(
    model="claude-sonnet-5",
    messages=[{"role": "user", "content": "What is a Lightning invoice?"}],
)
print(count.input_tokens)

JavaScript

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({ baseURL: "https://nymbot.ai/api", apiKey: process.env.NYMBOT_API_KEY });

const count = await client.messages.countTokens({
  model: "claude-sonnet-5",
  messages: [{ role: "user", content: "What is a Lightning invoice?" }],
});
console.log(count.input_tokens);

మోడళ్ల జాబితా

ప్రతి మోడల్ మరియు జనరేటర్ API అంగీకరిస్తుంది, దాని ధరతో. జాబితా అనువర్తనం యొక్క పికర్ వలె అదే ప్రత్యక్ష కేటలాగ్ నుండి చదవబడుతుంది, కాబట్టి ఇది ఎల్లప్పుడూ సర్వర్ నడుపుతుంది.

GET https://nymbot.ai/api/v1/models - కీ అవసరం లేదు. ఐదు నిమిషాలు క్యాష్ చేయబడింది.

GET /api/v1/models/{id} ఒక ఎంట్రీని తిరిగి ఇస్తుంది.

ధరలు అంటే మీరు చెల్లించేవి, ఫీజు మరియు మార్జిన్ ఇప్పటికే డాలర్లలో మరియు ప్రస్తుత బిట్కాయిన్ ధర వద్ద సాట్స్లో ఉన్నాయి. balance మోడల్ ఖర్చు చేసే సంతులనం ఏమిటో చెబుతుంది. nymbot_key ఇది యాప్లో మోడల్ యొక్క చిన్న పేరు. created ఎల్లప్పుడూ 0 ఉంటుంది, ఎందుకంటే ఒక మోడల్ను జోడించినప్పుడు కేటలాగ్ నమోదు చేయదు. ప్రచురించబడిన టోకెన్ రేట్లు లేని మోడల్ ధర నిర్ణయించబడుతుంది per_request బదులుగా.

nymbot/auto ఎల్లప్పుడూ మొదటిది, ధరగా... variable, ఎ తో routes ప్రతి ప్రామాణిక మార్గం యొక్క రేట్లను అందించే జాబితా. ఇది దృష్టి మరియు తర్కాన్ని జాబితా చేస్తుంది, కానీ సాధనాలను కాదు.

GET /api/v1/models/{id} అభ్యర్థనగా అదే పేర్లు మరియు మారుపేర్లను అంగీకరించి, వారు పరిష్కరించిన నమూనా కోసం ఎంట్రీని తిరిగి ఇస్తారు.

ప్రతిస్పందన

{
  "object": "list",
  "data": [
    {
      "id": "anthropic/claude-sonnet-5",
      "object": "model",
      "type": "chat",
      "owned_by": "anthropic",
      "name": "Claude Sonnet 5",
      "created": 0,
      "context_length": 1000000,
      "max_output_tokens": 64000,
      "architecture": { "input_modalities": ["text", "image"], "output_modalities": ["text"] },
      "supported_parameters": ["max_tokens", "temperature", "tools", "tool_choice", "reasoning", "response_format", "stop"],
      "capabilities": { "vision": true, "video": false, "tools": true, "reasoning": true, "web_search": true },
      "balance": "pro",
      "pricing": {
        "type": "per_token",
        "currency": "USD",
        "input_per_1M_tokens": 4.725,
        "output_per_1M_tokens": 23.625,
        "cache_read_per_1M_tokens": 0.4725,
        "sats_input_per_1M_tokens": 4038,
        "sats_output_per_1M_tokens": 20192
      },
      "description": "...",
      "nymbot_key": "claude-sonnet"
    }
  ]
}

మిగిలిన రకాలు:

• చిత్రం నమోదులు ఉన్నాయి capabilities (accepts_image_url, requires_image_url, edit) మరియు ధర per_generation.
• వీడియో నమోదులు ఉన్నాయి max_duration_seconds మరియు resolutions, మరియు ధర per_second ప్రతి తీర్మానం కోసం.
• ఆడియో నమోదులు ఉన్నాయి audio_type speech లేదా transcription, ధర per_1k_chars లేదా per_minute.
• ఎంబెడింగ్ నమోదులు ఉన్నాయి dimensions, context_length, max_inputs మరియు మిలియన్ ఇన్పుట్ టోకెన్లకు ధర.

గుర్తించబడిన ధరలు "estimated": true ధర ప్రచురించబడని జనరేటర్ కోసం అనువర్తనం యొక్క అంచనా. తెలియనిది type తిరిగి రావడం 400.

cURL

curl "https://nymbot.ai/api/v1/models?type=chat"

Python

import requests

models = requests.get("https://nymbot.ai/api/v1/models", params={"type": "chat"}).json()["data"]
for m in models:
    print(m["id"], m["balance"], m["pricing"].get("input_per_1M_tokens"))

JavaScript

const res = await fetch("https://nymbot.ai/api/v1/models?type=chat");
const { data } = await res.json();
for (const m of data) console.log(m.id, m.balance, m.pricing.input_per_1M_tokens);