प्रोवाइडर के डैशबोर्ड बताते हैं कि आपने कितना ख़र्च किया। वे शायद ही बताते हैं कि किस फ़ीचर या किस ग्राहक ने ख़र्च किया, और यह तो बिल्कुल नहीं बता सकते कि मंगलवार को बिल क्यों उछला। आपका अपना usage लॉग बता सकता है। यह पोस्ट लॉग का स्कीमा, उसे भरने वाला रैपर, हर कॉल की लागत निकालने का तरीक़ा, और निजी डेटा को बाहर रखने का तरीक़ा दिखाती है। इन आँकड़ों का क्या करें, यह कहीं और है: हर यूज़र की लागत और SaaS कीमतें और बजट और लूप गार्ड।
हर LLM कॉल के लिए क्या लॉग करें?
हर कोशिश की एक पंक्ति, रीट्राई समेत:
| फ़ील्ड | उदाहरण | क्यों |
|---|---|---|
ts |
2026-11-14T09:12:03Z | टाइम सीरीज़, घटनाओं की टाइमलाइन |
feature |
support_reply |
हर फ़ीचर की लागत |
user_hash |
hmac:4f1c… |
पहचान स्टोर किए बिना हर यूज़र की लागत |
tenant |
acme |
B2B ऐप में हर ग्राहक की लागत |
model |
broadnet/deepseek-v4.1-flash | कीमत देखना, मॉडलों की तुलना |
prompt_tokens |
18,240 | इनपुट की लागत |
cached_tokens |
16,384 | कैश्ड इनपुट सस्ता है; कैश रेट ट्रैक करें |
reasoning_tokens |
612 | reasoning मॉडलों पर छिपी आउटपुट लागत |
completion_tokens |
1,104 | आउटपुट की लागत (reasoning शामिल) |
cost_usd |
निकाली गई | वह संख्या जो फ़ाइनेंस माँगता है |
latency_ms, ttft_ms |
4,210 / 690 | परफ़ॉर्मेंस में गिरावट |
status |
200, 429, 503 | एरर और रीट्राई की दरें |
request_id |
X-Request-ID की वैल्यू |
सपोर्ट टिकट और इनवॉइस विवाद |
prompt_version |
support-v14 |
लागत के बदलाव को प्रॉम्प्ट के बदलाव से जोड़ता है |
न प्रॉम्प्ट का टेक्स्ट, न जवाब का टेक्स्ट। वे बाद में आते हैं, और सिर्फ़ रिडैक्शन के साथ।
हर कॉल की लागत कैसे निकालें?
usage ब्लॉक पढ़ें और हर टोकन प्रकार की कीमत अलग लगाएँ। BroadNet pricing.json में मशीन-पठनीय कीमतें प्रकाशित करता है, हर मॉडल के इनपुट, कैश्ड इनपुट और आउटपुट की प्रति-1M कीमतों के साथ:
import json, urllib.request
PRICES = {m["id"]: m for m in json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))["models"]}
def call_cost(model: str, usage) -> float:
p = PRICES[model]
details = getattr(usage, "prompt_tokens_details", None)
cached = (getattr(details, "cached_tokens", 0) or 0) if details else 0
new_input = usage.prompt_tokens - cached
return (
new_input * (p.get("input_per_m") or 0)
+ cached * (p.get("cached_input_per_m") or p.get("input_per_m") or 0)
+ usage.completion_tokens * (p.get("output_per_m") or 0)
) / 1_000_000
प्राइस फ़ाइल को कैश करें और हर कॉल पर लाने की जगह रोज़ रीफ़्रेश करें। दो आसान ग़लतियाँ: कैश्ड टोकन को नए इनपुट की कीमत पर गिनना (लागत बढ़ा-चढ़ाकर दिखती है), और यह भूल जाना कि reasoning टोकन पहले से completion_tokens के अंदर हैं (उन्हें दो बार न जोड़ें)।
लॉगिंग रैपर कैसा दिखता है?
import hashlib, hmac, os, time, logging
from openai import OpenAI
log = logging.getLogger("llm.usage")
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
HASH_KEY = os.environ["USAGE_HASH_KEY"].encode()
def user_hash(user_id: str) -> str:
return "hmac:" + hmac.new(HASH_KEY, user_id.encode(), hashlib.sha256).hexdigest()[:16]
def chat(*, feature: str, user_id: str, prompt_version: str, **kwargs):
t0 = time.perf_counter()
row = {"feature": feature, "user_hash": user_hash(user_id),
"model": kwargs["model"], "prompt_version": prompt_version}
try:
raw = client.chat.completions.with_raw_response.create(**kwargs)
resp = raw.parse()
u = resp.usage
d = getattr(u, "completion_tokens_details", None)
row.update(
status=200,
request_id=raw.headers.get("x-request-id"),
prompt_tokens=u.prompt_tokens,
cached_tokens=getattr(getattr(u, "prompt_tokens_details", None), "cached_tokens", 0) or 0,
reasoning_tokens=(getattr(d, "reasoning_tokens", 0) or 0) if d else 0,
completion_tokens=u.completion_tokens,
cost_usd=round(call_cost(kwargs["model"], u), 6),
)
return resp
except Exception as e:
row.update(status=getattr(e, "status_code", "error"),
request_id=getattr(getattr(e, "response", None), "headers", {}).get("x-request-id"))
raise
finally:
row["latency_ms"] = int((time.perf_counter() - t0) * 1000)
log.info("llm_call", extra={"llm": row})
with_raw_response आपको हेडर देता है, ताकि आप X-Request-ID रख सकें। स्ट्रीम वाले कॉल के लिए stream_options={"include_usage": True} जोड़ें और पंक्ति आख़िरी चंक से भरें, जैसा SSE स्ट्रीमिंग वाली पोस्ट में दिखाया है। HASH_KEY को गुप्त और स्थिर रखें: एक ही यूज़र हमेशा एक ही हैश बनता है, पर key के बिना हैश को उलटा नहीं जा सकता।
लागत को यूज़र्स और फ़ीचर्स से कैसे जोड़ें?
ऊपर की पंक्तियाँ किसी भी SQL स्टोर में हों, तो बँटवारा एक क्वेरी है:
SELECT feature, model,
count(*) AS calls,
sum(cost_usd) AS cost,
sum(cached_tokens)::float / nullif(sum(prompt_tokens), 0) AS cache_rate,
avg(completion_tokens) AS avg_out
FROM llm_calls
WHERE ts >= now() - interval '7 days'
GROUP BY feature, model
ORDER BY cost DESC;
हर ग्राहक की लागत के लिए feature की जगह user_hash या tenant लगाएँ। तीन अगले क़दम जल्दी फ़ायदा देते हैं:
- लागत के हिसाब से टॉप 1% यूज़र। अक्सर कोई एक लूप या बॉट। गिरता हुआ
cache_rateदूसरी शुरुआती चेतावनी है; प्रॉम्प्ट कैशिंग कैलकुलेटर दिखाता है कि कैश रेट का हर पॉइंट कितने का है। - हर सफल नतीजे की लागत, हर कॉल की नहीं: अपने सफलता वाले इवेंट से जोड़ें।
- रीट्राई का हिस्सा। 429 या 5xx स्टेटस वाली पंक्तियाँ दिखाती हैं कि आप विफलताओं पर कितना ख़र्च करते हैं; देखें 429 एरर सँभालना।
LLM लॉग से PII को बाहर कैसे रखें?
सबसे सुरक्षित लॉग वह है जिसमें प्रॉम्प्ट टेक्स्ट बिल्कुल न हो। जब डीबगिंग या eval के लिए टेक्स्ट चाहिए, तो ये क़दम इसी क्रम में अपनाएँ:
- सैंपल करें। टेक्स्ट कॉल के एक छोटे हिस्से और विफलताओं के लिए रखें, सब कुछ के लिए नहीं।
- लिखने से पहले रिडैक्ट करें। रिडैक्शन उसी प्रोसेस में चलाएँ जो लॉग लिखता है। बाद में रिडैक्ट करने का मतलब है कि कच्चा टेक्स्ट पहले से डिस्क पर और बैकअप में है।
- डिटेक्टर की परतें लगाएँ। स्ट्रक्चर्ड डेटा के लिए regex, नामों और पतों के लिए NER टूल।
- अलग स्टोर करें। टेक्स्ट को सख़्त एक्सेस और कम रिटेंशन वाली अलग टेबल या बकेट में रखें,
request_idसे जुड़ा हुआ। - सीक्रेट कभी लॉग न करें। OWASP लॉगिंग चीट शीट बाहर रखे जाने वाले डेटा में एक्सेस टोकन, पासवर्ड और एन्क्रिप्शन key गिनाती है; API key भी उसी सूची में है।
एक न्यूनतम regex परत:
import re
PATTERNS = [
(re.compile(r"[\w.+-]+@[\w-]+\.[\w.-]+"), "[EMAIL]"),
(re.compile(r"\+?\d[\d\s().-]{7,}\d"), "[PHONE]"),
(re.compile(r"\b(?:\d[ -]?){13,19}\b"), "[CARD]"),
(re.compile(r"\b(sk|key|bearer)[-_ ]?[A-Za-z0-9]{16,}\b", re.I), "[SECRET]"),
]
def redact(text: str) -> str:
for pat, label in PATTERNS:
text = pat.sub(label, text)
return text
यह साफ़ मामलों को पकड़ता है और नाम, पते और कुछ भी असामान्य छोड़ देता है। Microsoft Presidio इनके लिए एंटिटी रिकग्निशन जोड़ता है, और उसका README साफ़ कहता है कि इसकी कोई गारंटी नहीं कि वह सारी संवेदनशील जानकारी ढूँढ लेगा। चूकों के लिए योजना बनाएँ: कम रिटेंशन और सख़्त एक्सेस, किसी चूक के निकल जाने पर नुक़सान सीमित करते हैं।
BroadNet Inference कहाँ काम आता है
BroadNet Inference, जब मॉडल रिपोर्ट करे तब कैश्ड और reasoning टोकन के साथ usage ब्लॉक लौटाता है, हर रिस्पॉन्स पर X-Request-ID देता है, और एक पब्लिक प्राइस फ़ाइल रखता है जिसे आप लागत निकालने के लिए लोड कर सकते हैं। उसकी तरफ़, प्रॉम्प्ट और जवाब अनुरोध के लिए प्रोसेस होते हैं और रखे नहीं जाते; वह सिर्फ़ बिना कंटेंट वाले रिकॉर्ड रखता है, जैसे समय, टोकन की संख्या और लागत (ज़ीरो डेटा रिटेंशन कैसे काम करता है)। इससे किसी भी प्रॉम्प्ट टेक्स्ट की अकेली कॉपी आपके अपने लॉग बन जाते हैं, इसलिए ऊपर के रिडैक्शन नियम ही आपकी असली रिटेंशन तय करते हैं। BroadNet के चैट अनुरोधों में हर यूज़र के मेटाडेटा का कोई फ़ील्ड नहीं है, इसलिए बँटवारा आपके रैपर में होता है। हर टीम के अलग बजट के लिए अलग key इस्तेमाल करें; key गाइड लेबल और allow-list कवर करती है।
