BroadRouter
शुरू करें

LLM API usage लॉगिंग: हर यूज़र और फ़ीचर की लागत, PII हटाकर

BroadNet Inference टीम · 4 मिनट में पढ़ें · प्रकाशित

हर LLM कॉल को एक फ़ंक्शन में लपेटें जो मॉडल, फ़ीचर, हैश किया हुआ यूज़र ID, prompt, cached, reasoning और आउटपुट टोकन, लागत, लेटेंसी, स्टेटस और प्रोवाइडर का अनुरोध ID दर्ज करे। लागत इनवॉइस से नहीं, प्राइस टेबल से निकालें। डिफ़ॉल्ट रूप से मेटाडेटा लॉग करें; अगर प्रॉम्प्ट टेक्स्ट रखना ही है, तो लिखने से पहले उसमें से निजी जानकारी हटाएँ और कम समय की रिटेंशन रखें।

प्रोवाइडर के डैशबोर्ड बताते हैं कि आपने कितना ख़र्च किया। वे शायद ही बताते हैं कि किस फ़ीचर या किस ग्राहक ने ख़र्च किया, और यह तो बिल्कुल नहीं बता सकते कि मंगलवार को बिल क्यों उछला। आपका अपना 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. लागत के हिसाब से टॉप 1% यूज़र। अक्सर कोई एक लूप या बॉट। गिरता हुआ cache_rate दूसरी शुरुआती चेतावनी है; प्रॉम्प्ट कैशिंग कैलकुलेटर दिखाता है कि कैश रेट का हर पॉइंट कितने का है।
  2. हर सफल नतीजे की लागत, हर कॉल की नहीं: अपने सफलता वाले इवेंट से जोड़ें।
  3. रीट्राई का हिस्सा। 429 या 5xx स्टेटस वाली पंक्तियाँ दिखाती हैं कि आप विफलताओं पर कितना ख़र्च करते हैं; देखें 429 एरर सँभालना।

LLM लॉग से PII को बाहर कैसे रखें?

सबसे सुरक्षित लॉग वह है जिसमें प्रॉम्प्ट टेक्स्ट बिल्कुल न हो। जब डीबगिंग या eval के लिए टेक्स्ट चाहिए, तो ये क़दम इसी क्रम में अपनाएँ:

  1. सैंपल करें। टेक्स्ट कॉल के एक छोटे हिस्से और विफलताओं के लिए रखें, सब कुछ के लिए नहीं।
  2. लिखने से पहले रिडैक्ट करें। रिडैक्शन उसी प्रोसेस में चलाएँ जो लॉग लिखता है। बाद में रिडैक्ट करने का मतलब है कि कच्चा टेक्स्ट पहले से डिस्क पर और बैकअप में है।
  3. डिटेक्टर की परतें लगाएँ। स्ट्रक्चर्ड डेटा के लिए regex, नामों और पतों के लिए NER टूल।
  4. अलग स्टोर करें। टेक्स्ट को सख़्त एक्सेस और कम रिटेंशन वाली अलग टेबल या बकेट में रखें, request_id से जुड़ा हुआ।
  5. सीक्रेट कभी लॉग न करें। 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 कवर करती है।

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

हर यूज़र की LLM API लागत कैसे ट्रैक करूँ?

हर कॉल पर यूज़र का पहचानकर्ता लगाएँ, रिस्पॉन्स से usage ब्लॉक पढ़ें, टोकन की संख्या को अपनी प्राइस टेबल से गुणा करें, और हर कॉल की एक लॉग पंक्ति लिखें। यूज़र टैग से ग्रुप करें। ईमेल की जगह हैश किया हुआ ID इस्तेमाल करें।

क्या पूरे प्रॉम्प्ट और जवाब लॉग करूँ?

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

मेरी निकाली गई लागत प्रोवाइडर के इनवॉइस से अलग क्यों है?

आम तौर पर इसलिए कि कैश्ड टोकन को नए इनपुट की कीमत पर गिना गया, reasoning टोकन आउटपुट से छूट गए, या रीट्राई लॉग नहीं हुए। हर कोशिश लॉग करें, उन फ़ेल हुई कोशिशों समेत जिन्होंने usage लौटाया।

स्ट्रीमिंग रिस्पॉन्स से टोकन usage कैसे मिलेगा?

stream_options में include_usage को true सेट करें। तब आख़िरी चंक में ख़ाली choices सूची के साथ usage ब्लॉक आता है।

LLM लॉग के लिए कौन-सा PII रिडैक्शन टूल इस्तेमाल करूँ?

ईमेल, फ़ोन नंबर और कार्ड नंबर जैसे स्ट्रक्चर्ड डेटा के लिए regex से शुरू करें, और नामों और पतों के लिए Microsoft Presidio जैसा NER-आधारित टूल जोड़ें। Presidio का अपना README कहता है कि वह सब कुछ ढूँढने की गारंटी नहीं दे सकता।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें