המדיניות PromptTokenLimit

מדיניות ניתנת להרחבה

הדף הזה רלוונטי ל-Apigee ול-Apigee Hybrid.

אפשר לעיין במסמכי העזרה של Apigee Edge.

סקירה כללית

המדיניות PromptTokenLimit מגינה על הקצה העורפי של מודל שפה גדול (LLM) מפני עומסי תנועה, על ידי הגבלת מספר הטוקנים בהנחיות של המשתמשים.

המדיניות PromptTokenLimit דומה למדיניות SpikeArrest, אבל המדיניות SpikeArrest מגבילה את מספר הבקשות, ואילו המדיניות PromptTokenLimit מגבילה את מספר הטוקנים בבקשות האלה. המדיניות הזו מיועדת במיוחד לאפליקציות LLM שבהן העלות והביצועים קשורים באופן ישיר למספר הטוקנים שעוברים עיבוד.

המדיניות הזו היא מדיניות ניתנת להרחבה, והשימוש בה עשוי להשפיע על העלות או על הניצול, בהתאם לרישיון Apigee שלכם. למידע על סוגי המדיניות וההשלכות של השימוש בהם, קראו את המאמר סוגי מדיניות.

ההבדל בין PromptTokenLimit לבין LLMTokenQuota

המדיניות PromptTokenLimit משמשת לניהול תנועה תפעולית כדי למנוע עליות חדות פתאומיות בשימוש בטוקנים. לעומת זאת, המדיניות LLMTokenQuota משמשת לאכיפת מגבלות צריכה באפליקציות לקוח לאורך תקופות ארוכות יותר (כמו שעות, ימים או חודשים) כדי לנהל את העלויות ולאכוף הסכמים עסקיים.

רכיב PromptTokenLimit

מגדירה את המדיניות PromptTokenLimit.

ערך ברירת המחדל מידע נוסף מופיע בקטע הכרטיסייה "מדיניות ברירת המחדל" שבהמשך.
חובה? אופציונלי
סוג אובייקט מורכב
רכיב הורה לא רלוונטי
רכיבי צאצא <Identifier>
<Rate> (חובה)
<UseEffectiveCount>
<UserPromptSource>
<IgnoreUnresolvedVariables>

תחביר

הרכיב PromptTokenLimit משתמש בתחביר הבא:

<PromptTokenLimit continueOnError="false" enabled="true" name="POLICY_NAME">
  <DisplayName></DisplayName>
  <Properties/>
  <UserPromptSource>{jsonPath('$.contents[-1].parts[-1].text',request.content,true)}</UserPromptSource>
  <Identifier ref=""/>
  <Rate ref="">[pm|ps]</Rate>
  <UseEffectiveCount>[false|true]</UseEffectiveCount>
  <IgnoreUnresolvedVariables>[false|true]</IgnoreUnresolvedVariables>
</PromptTokenLimit>

מדיניות ברירת המחדל

בדוגמה הבאה מוצגות הגדרות ברירת המחדל כשמוסיפים מדיניות PromptTokenLimit לתהליך בממשק המשתמש:

<PromptTokenLimit continueOnError="false" enabled="true" name="PTL-limitTokens-1">
  <DisplayName></DisplayName>
  <Properties/>
  <UserPromptSource>{jsonPath('$.contents[-1].parts[-1].text',request.content,true)}</UserPromptSource>
  <Identifier ref=""/>
  <Rate ref="">[pm|ps]</Rate>
  <UseEffectiveCount>[false|true]</UseEffectiveCount>
  <IgnoreUnresolvedVariables>[false|true]</IgnoreUnresolvedVariables>
</PromptTokenLimit>

לרכיב הזה יש את המאפיינים הבאים שמשותפים לכל המדיניות:

מאפיין ברירת מחדל חובה? תיאור
name לא רלוונטי חובה

השם הפנימי של המדיניות. הערך של מאפיין name יכול להכיל אותיות, מספרים, רווחים, מקפים, קווים תחתונים ונקודות. הערך הזה לא יכול להיות ארוך מ-255 תווים.

אפשר להשתמש ברכיב <DisplayName> כדי לתת למדיניות תווית בשם אחר בשפה טבעית בכלי לעריכת פרוקסי בממשק המשתמש לניהול.
continueOnError FALSE אופציונלי מגדירים את הערך false כדי להחזיר שגיאה אם המדיניות נכשלת. זו התנהגות צפויה ברוב המקרים. הגדרה ל-true מאפשרת להמשיך את הביצוע של התהליך גם אחרי שמדיניות נכשלת. מאמרים קשורים:
enabled TRUE אופציונלי מגדירים את הערך true כדי לאכוף את המדיניות, או את הערך false כדי להשבית את המדיניות. המדיניות לא נאכפת גם אם היא עדיין משויכת לזרימה.
async   FALSE הוצא משימוש המאפיין הזה הוצא משימוש.

דוגמאות

הדוגמאות הבאות ממחישות כמה מהדרכים שבהן אפשר להשתמש במדיניות PromptTokenLimit:

דוגמה 1

הגבלת אסימוני הנחיה ברפליקה אחת.

בדוגמה הזו, הגבלת טוקנים של פרומפט מתרחשת בתוך רפליקה יחידה ולא מופצת בין כמה מעבדי הודעות באזור. 

<PromptTokenLimit continueOnError="false" enabled="true" name="PTL-limitTokens-1">
  <DisplayName></DisplayName>
  <Properties/>
  <UserPromptSource>{jsonPath('$.contents[-1].parts[-1].text',request.content,true)}</UserPromptSource>
  <Identifier ref="request.url"/>
  <Rate>1pm</Rate>
  <UseEffectiveCount>false</UseEffectiveCount>
</PromptTokenLimit>

דוגמה 2

הגבלת טוקנים מבוזרת.

בדוגמה הזו, הגבלת הטוקנים של ההנחיות מפוזרת בין כמה רפליקות באזור, ונעשה שימוש באלגוריתם להגבלת קצב של יצירת בקשות מסוג "חלון הזזה".

<PromptTokenLimit continueOnError="false" enabled="true" name="PTL-limitTokens-1">
  <DisplayName></DisplayName>
  <Properties/>
  <UserPromptSource>{jsonPath('$.contents[-1].parts[-1].text',request.content,true)}</UserPromptSource>
  <Identifier ref="request.url"/>
  <Rate>1pm</Rate>
  <UseEffectiveCount>true</UseEffectiveCount>
</PromptTokenLimit>

דוגמה 3

הגבלת מספר הטוקנים לכל בקשה בהתאם לגודל חלון ההקשר.

בדוגמה הזו, הגבלת הטוקנים של הפרומפט מתרחשת בתוך רפליקה יחידה ולא מופצת בין כמה מעבדי הודעות באזור. ההגדרה הספציפית הזו משמשת להגבלת מספר הטוקנים לכל בקשה בגודל חלון ההקשר.

<PromptTokenLimit continueOnError="false" enabled="true" name="PTL-limitTokens-1">
  <DisplayName></DisplayName>
  <Properties/>
  <UserPromptSource>{jsonPath('$.messages',request.content,true)}</UserPromptSource>
  <Identifier ref="messageid"/>
  <Rate>1pm</Rate>
  <UseEffectiveCount>false</UseEffectiveCount>
</PromptTokenLimit>

דוגמה 4

הגבלת טוקנים מבוזרת עם ערכי ברירת מחדל.

בדוגמה הזו, הגבלת הטוקנים של ההנחיות מתרחשת ברפליקה אחת ולא מופצת בין כמה מעבדי בקשות באזור. נעשה שימוש בערך ברירת המחדל של מקור ההנחיה למשתמש: {jsonPath('$.messages',request.content,true)} 

<PromptTokenLimit continueOnError="false" enabled="true" name="PTL-limitTokens-1">
  <DisplayName></DisplayName>
  <Properties/>
  <Identifier ref="messageid"/>
  <Rate>1pm</Rate>
  <UseEffectiveCount>false</UseEffectiveCount>
</PromptTokenLimit>

הפניה לרכיב צאצא

בקטע הזה מתוארים רכיבי הצאצא של <PromptTokenLimit>.

<DisplayName>

אפשר להשתמש במאפיין הזה בנוסף למאפיין name כדי לתת למדיניות שם אחר, שנשמע יותר טבעי, ב-UI של עורך ה-proxy לניהול.

הרכיב <DisplayName> משותף לכל סוגי המדיניות.

ערך ברירת המחדל לא רלוונטי
חובה? זה שינוי אופציונלי. אם לא מציינים את <DisplayName>, המערכת משתמשת בערך של מאפיין name של המדיניות.
סוג String
רכיב אב <PolicyElement>
רכיבי צאצא ללא

רכיב <DisplayName> משתמש בתחביר הבא:

תחביר

<PolicyElement>
  <DisplayName>POLICY_DISPLAY_NAME</DisplayName>
  ...
</PolicyElement>

דוגמה

<PolicyElement>
  <DisplayName>My Validation Policy</DisplayName>
</PolicyElement>

לרכיב <DisplayName> אין מאפיינים או רכיבי צאצא.

<Identifier>

מאפשרת לבחור איך לקבץ את הבקשות כדי שאפשר יהיה להחיל את המדיניות PromptTokenLimit על סמך הלקוח. לדוגמה, אפשר לקבץ בקשות לפי מזהה מפתח, ובמקרה כזה הבקשות של כל מפתח ייספרו במסגרת מגבלת PromptTokenLimit שלו, ולא כל הבקשות לשרת ה-proxy.

אם משאירים את הרכיב <Identifier> ריק, מגבלת קצב אחת נאכפת על כל הבקשות ל-API proxy הזה.

ערך ברירת מחדל לא רלוונטי
חובה? אופציונלי
סוג String
רכיב הורה <PromptTokenLimit>
רכיבי צאצא ללא

תחביר

<PromptTokenLimit
  continueOnError="[false|true]"
  enabled="[true|false]"
  name="POLICY_NAME"
>
  <Identifier ref="FLOW_VARIABLE"/>
</PromptTokenLimit>

דוגמה 1

בדוגמה הבאה, המדיניות PromptTokenLimit חלה על כל מזהה מפתח:

<PromptTokenLimit name="PTL-limitTokens-1">
  <Identifier ref="developer.id"/>
  <Rate>42pm</Rate/>
  <UseEffectiveCount>true</UseEffectiveCount>
</PromptTokenLimit>

בטבלה הבאה מתוארים המאפיינים של <Identifier>:

מאפיין תיאור ברירת מחדל נוכחות
ref מזהה את המשתנה שלפיו PromptTokenLimit מקבץ בקשות נכנסות. אפשר להשתמש בכל משתנה זרימה כדי לציין לקוח ייחודי, כמו אלה שזמינים עם מדיניות VerifyAPIKey. אפשר גם להגדיר משתנים בהתאמה אישית באמצעות מדיניות JavaScript או מדיניות AssignMessage. לא רלוונטי חובה

<Rate>

מציינת את הקצב שבו מגבילים את העליות החדות (או הזינוקים) בטוקנים, על ידי הגדרת מספר הטוקנים שמותרים במרווחים של דקה או שנייה. אפשר להשתמש ברכיב הזה בשילוב עם <Identifier> כדי לווסת את התנועה בצורה חלקה בזמן הריצה על ידי קבלת ערכים מהלקוח. משתמשים ברכיב <UseEffectiveCount> כדי להגדיר את אלגוריתם הגבלת קצב של יצירת בקשות שבו נעשה שימוש במדיניות.

ערך ברירת המחדל לא רלוונטי
חובה? חובה
סוג מספר שלם
רכיב הורה <PromptTokenLimit>
רכיבי צאצא ללא

תחביר

אפשר לציין תעריפים באחת מהדרכים הבאות:

  • תעריף קבוע שאתם מציינים בגוף הרכיב <Rate>
  • ערך משתנה, שאפשר להעביר על ידי הלקוח; מזהים את שם משתנה הזרימה באמצעות המאפיין ref
<PromptTokenLimit
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="POLICY_NAME"
>
  <Rate ref="FLOW_VARIABLE">RATE[pm|ps]</Rate>
</PromptTokenLimit>

ערכי שיעור תקינים (מוגדרים כערך משתנה או בגוף הרכיב) צריכים להיות בפורמט הבא:

  • ‫intps (מספר הטוקנים לשנייה, מוחלק למרווחי זמן של אלפיות השנייה)
  • ‫intpm (מספר הטוקנים לדקה, מוחלק למרווחים של שניות)

הערך של int חייב להיות מספר שלם חיובי שאינו אפס.

דוגמה 1

בדוגמה הבאה, הקצב מוגדר ל-5 אסימונים לשנייה:

<PromptTokenLimit name="PTL-Static-5ps">
  <Rate>5ps</Rate>
  <UseEffectiveCount>false</UseEffectiveCount>
</PromptTokenLimit>

המדיניות מחליקה את הקצב לאסימון אחד שמותר כל 200 אלפיות השנייה (1000/5).

דוגמה 2

בדוגמה הבאה, הקצב מוגדר ל-12 אסימונים לדקה:

<PromptTokenLimit name="PTL-Static-12pm">
  <Rate>12pm</Rate>
  <UseEffectiveCount>false</UseEffectiveCount>
</PromptTokenLimit>

המדיניות לדוגמה הזו מחליקה את הקצב לאסימון אחד שמותר כל חמש שניות (60/12).

בטבלה הבאה מתוארים המאפיינים של <Rate>:

מאפיין תיאור נוכחות ברירת מחדל
ref מזהה משתנה זרימה שמציין את הקצב. יכול להיות שזה יהיה משתנה של זרימת נתונים, כמו פרמטר של שאילתת HTTP, כותרת או תוכן של גוף ההודעה, או ערך כמו KVM. מידע נוסף זמין במאמר חומר עזר בנושא משתני זרימה.

אפשר גם להשתמש במשתנים מותאמים אישית באמצעות מדיניות JavaScript או מדיניות AssignMessage.

אם מגדירים גם את ref וגם את גוף הרכיב הזה, הערך של ref מוחל ומקבל עדיפות כשהמשתנה של התהליך מוגדר בבקשה. (ההפך הוא הנכון כשהמשתנה שזוהה ב-ref לא מוגדר בבקשה).

לדוגמה:

<Rate ref="request.header.custom_rate">1pm</Rate>

בדוגמה הזו, אם הלקוח לא מעביר כותרת custom_rate, אז הקצב של ה-proxy ל-API הוא טוקן אחד לדקה לכל הלקוחות. אם הלקוח מעביר כותרת custom_rate שהערך שלה הוא 10ps, לכל הלקוחות בשרת ה-proxy – עד שנשלחת בקשה בלי הכותרת custom_rate.

אפשר להשתמש ב-<Identifier> כדי לקבץ בקשות ולאכוף תעריפים מותאמים אישית לסוגים שונים של לקוחות.

אם מציינים ערך ל-ref אבל לא מגדירים את הקצב בגוף של הרכיב <Rate> והלקוח לא מעביר ערך, המדיניות PromptTokenLimit מחזירה שגיאה.

 אופציונלי לא רלוונטי
בטבלה הבאה מפורטים המאפיינים של Rate שמגדירים את ההתנהגות של הגבלת התנועה:
מאפיין תיאור
messagesPerPeriod מציין את מספר האסימונים המותרים בפרק זמן מוגדר. לדוגמה, אם מדיניות מוגדרת ל-'10ps' (10 אסימונים לשנייה), הערך של messagesPerPeriod יהיה 10.
periodInMicroseconds מגדירה את התקופה, במיקרו-שניות, שבה מחושב הערך של messagesPerPeriod. בהגדרה של "10ps", הערך הזה יהיה 1,000,000, ששווה לשנייה אחת.
maxBurstMessageCount מייצג את המספר המקסימלי של טוקנים שאפשר לאפשר באופן מיידי או בפרק זמן קצר בתחילת מרווח חדש.

<UseEffectiveCount>

האלמנט הזה מאפשר לכם לבחור בין אלגוריתמים שונים של PromptTokenLimit על ידי הגדרת הערך ל-true או ל-false, כמו שמוסבר בהמשך:

TRUE

אם המדיניות מוגדרת לערך true, המגבלה PromptTokenLimit מופצת באזור. המשמעות היא שספירת הבקשות מסונכרנת בין מעבדי ההודעות (MP) באזור. בנוסף, נעשה שימוש באלגוריתם של הגבלת קצב של יצירת בקשות מסוג 'חלון נע'. האלגוריתם הזה מספק התנהגות עקבית של הגבלת קצב של יצירת בקשות, ולא "מחליק" את מספר הבקשות הנכנסות שאפשר לשלוח לקצה העורפי. אם נשלח פרץ של בקשות בפרק זמן קצר, הן מותרות כל עוד הן לא חורגות ממגבלת הקצב שהוגדרה ברכיב <Rate>. לדוגמה:

<PromptTokenLimit name="Prompt-Token-Limit-1">
  <Rate>12pm</Rate>
  <Identifier ref="client_id" />
  <UseEffectiveCount>true</UseEffectiveCount>
</PromptTokenLimit>

false (ברירת מחדל)

אם המדיניות מוגדרת ל-false (ברירת המחדל), היא משתמשת באלגוריתם של token bucket כדי להחלק את העליות החדות בשימוש באסימונים. האלגוריתם מחלק את מגבלת הקצב שאתם מציינים למרווחים קטנים יותר. החיסרון בגישה הזו הוא שאסימונים לגיטימיים רבים שמגיעים בפרק זמן קצר עלולים להידחות.

לדוגמה, נניח שהזנתם קצב של 30pm (30 טוקנים לדקה). בבדיקות, יכול להיות שתחשבו שאתם יכולים לשלוח 30 טוקנים בשנייה אחת, כל עוד הם מגיעים תוך דקה. אבל זה לא האופן שבו המדיניות אוכפת את ההגדרה. אם חושבים על זה, 30 טוקנים בשנייה אחת יכולים להיחשב כעלייה קטנה בסביבות מסוימות.

  • התעריפים לדקה מוחלקים לבקשות מלאות שמותרות במרווחים של שניות.

    לדוגמה, אם מגדירים 30pm, ההחלקה תתבצע כך:
    60 שניות (דקה אחת) / 30pm = אינטרוולים של 2 שניות, או טוקן אחד מותר כל 2 שניות. אם תשלחו טוקן שני תוך 2 שניות, הוא ייכשל. בנוסף, אם תנסו להשתמש בטוקן ה-31 בתוך דקה, הפעולה תיכשל.

  • שיעורים של לשנייה מוחלקים לבקשות מלאות שמותרות במרווחי זמן של אלפיות השנייה.

    לדוגמה, אם המהירות היא 10ps, ההחלקה תתבצע כך:
    1,000 מילישניות (1 שנייה) חלקי 10ps = מרווחים של 100 מילישניות, או טוקן אחד מותר כל 100 מילישניות. אם תנסו ליצור טוקן שני בתוך 100 אלפיות השנייה, הפעולה תיכשל. בנוסף, אם תנסו להנפיק אסימון 11 בתוך שנייה, הפעולה תיכשל.

ערך ברירת המחדל לא נכון
חובה? אופציונלי
סוג בוליאני
רכיב הורה <PromptTokenLimit>
רכיבי צאצא ללא

בטבלה הבאה מתוארים המאפיינים של הרכיב <UseEffectiveCount>:

מאפיין תיאור ברירת מחדל נוכחות
ref מזהה את המשתנה שמכיל את הערך של <UseEffectiveCount>. זה יכול להיות כל משתנה זרימה, כמו פרמטר של שאילתת HTTP, כותרת או תוכן של גוף ההודעה. מידע נוסף זמין במאמר חומר עזר בנושא משתני זרימה. אפשר גם להגדיר משתנים בהתאמה אישית באמצעות מדיניות JavaScript או מדיניות AssignMessage. לא רלוונטי אופציונלי

<UserPromptSource>

המקור לאחזור טקסט של הנחיה למשתמש. שימוש ב תבנית הודעה.

תבנית ההודעה צריכה לספק ערך יחיד של טקסט הפרומפט של המשתמש.

לדוגמה, {jsonPath('$.contents[-1].parts[-1].text',request.content,true)}.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג String
רכיב הורה <PromptTokenLimit>
רכיבי צאצא ללא

תחביר

<PromptTokenLimit
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="POLICY_NAME">
  <UserPromptSource>{jsonPath('$.contents[-1].parts[-1].text',request.content,true)}</UserPromptSource>
</PromptTokenLimit>

דוגמה 1

<PromptTokenLimit name="Prompt-Token-Limit-1">
  <UserPromptSource>{jsonPath('$.contents[-1].parts[-1].text',request.content,true)}</UserPromptSource>
</PromptTokenLimit>

<IgnoreUnresolvedVariables>

ההגדרה הזו קובעת אם העיבוד ייפסק כשהמערכת תיתקל במשתנה לא פתור.

הערך true מאפשר להתעלם ממשתנים שלא נפתרו ולהמשיך בעיבוד. אחרת false. ערך ברירת המחדל הוא false.

ערך ברירת המחדל לא נכון
חובה? אופציונלי
סוג בוליאני
רכיב הורה <PromptTokenLimit>
רכיבי צאצא ללא

תחביר

<PromptTokenLimit
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="POLICY_NAME">
  <IgnoreUnresolvedVariables>[true|false]</IgnoreUnresolvedVariables>
</PromptTokenLimit>

דוגמה

<PromptTokenLimit name="Prompt-Token-Limit-1">
  <Rate>10ps</Rate>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</PromptTokenLimit>

משתני זרימה

כשמדיניות PromptTokenLimit מופעלת, משתני הזרימה הבאים מאוכלסים:

משתנה סוג הרשאה תיאור
ratelimit.POLICY_NAME.failed בוליאני הרשאת קריאה בלבד המשתנה הזה הוא true אם הייתה שגיאת ביצוע פנימית במדיניות. אין להשתמש במשתנה הזה כדי לבדוק אם חרגתם ממגבלת הקצב. יכול להיות שהיא מוגדרת ל-true בעומס גבוה בגלל העיצוב של המדיניות, שמאפשר גישה במקרה של כשל.
ratelimit.POLICY_NAME.resolvedUserPrompt String קריאה בלבד הפונקציה מחזירה את ההנחיה שחולצה מהמשתמש.
ratelimit.POLICY_NAME.userPromptSource String הרשאת קריאה בלבד הפונקציה מחזירה את תבנית ההודעה לפרומפט של המשתמש שצוין במדיניות.
ratelimit.POLICY_NAME.userPromptTokenCount String קריאה בלבד הפונקציה מחזירה את מספר הטוקנים של הנחיית המשתמש שחולצה.

מידע נוסף זמין במאמר חומר עזר בנושא משתני זרימה.

הפניה לשגיאה

בקטע הזה מתוארים קודי השגיאות והודעות השגיאה שמוחזרים, ומשתני השגיאה שמוגדרים על ידי Apigee כשמדיניות כזו מפעילה שגיאה. יכול להיות שיוצגו גם שגיאות במדיניות SpikeArrest. חשוב לדעת את המידע הזה אם אתם מפתחים כללי תקלות לטיפול בתקלות. מידע נוסף זמין במאמרים בנושא מה צריך לדעת על שגיאות שקשורות למדיניות ו.

שגיאות זמן ריצה

השגיאות האלה יכולות להתרחש כשהמדיניות מופעלת.

קוד תקלה סטטוס HTTP תקלה ב-Apigee מטרה תיקון
policies.prompttokenlimit.FailedToExtractUserPrompt 400 לא נכון לא ניתן לחלץ את ההנחיה למשתמש מבקשת ה-API.
policies.prompttokenlimit.PromptTokenLimitViolation 429 לא נכון הפרה של PromptTokenLimit.
policies.prompttokenlimit.FailedToCalculateUserPromptTokens 500 TRUE אי אפשר לחשב את מספר הטוקנים בהנחיה למשתמש.

שגיאות בהטמעה

השגיאות האלה יכולות להתרחש כשפורסים שרת proxy שמכיל את המדיניות הזו.

קוד תקלה סטטוס HTTP תקלה ב-Apigee מטרה תיקון
policies.prompttokenlimit.MessageWeightNotSupported 500 לא נכון המאפיין MessageWeight לא נתמך במדיניות PromptTokenLimit.

משתני תקלות

המשתנים האלה מוגדרים כשמתרחשת שגיאת זמן ריצה. מידע נוסף על שגיאות שקשורות למדיניות

משתנים כאשר: דוגמה
ratelimit.policy_name.fault.name ‫fault_name הוא שם התקלה, כפי שמופיע בטבלה שגיאות בזמן ריצה שלמעלה. שם התקלה הוא החלק האחרון של קוד התקלה. fault.name Matches "PromptTokenLimitViolation"
ratelimit.policy_name.failed ‫policy_name הוא השם שהמשתמש הגדיר למדיניות שגרמה לשגיאה. ratelimit.PTL-PromptTokenLimitPolicy.failed = true

דוגמה לתגובת שגיאה

דוגמה לתגובה עם שגיאה:

{  
   "fault":{  
      "detail":{  
         "errorcode":"policies.prompttokenlimit.PromptTokenLimitViolation"
      },
      "faultstring":"Prompt Token Limit Violation. Allowed rate : MessageRate{capacity=10, period=Minutes}"
   }
}

דוגמה לכלל שגיאה

בדוגמה הבאה מוצג כלל לטיפול בשגיאות שנועד לטפל בשגיאת PromptTokenLimitViolation:

<FaultRules>
    <FaultRule name="Prompt Token Limit Errors">
        <Step>
            <Name>Assign-Message-1</Name>
        </Step>
        <Condition>(fault.name Matches "PromptTokenLimitViolation")</Condition>
    </FaultRule>
</FaultRules>

קוד הסטטוס הנוכחי של HTTP לחריגה ממגבלת הקצב שנקבעה על ידי מדיניות LLMTokenQuota או PromptTokenLimit הוא 429 (יותר מדי בקשות).

סכימות

כל סוג מדיניות מוגדר על ידי סכימת XML‏ (.xsd). סכימות המדיניות זמינות ב-GitHub.

נושאים קשורים