Thinking budget ಜೊತೆಗೆ Gemini 2.5 Flash streaming adapter ಅನ್ನು ಅಳವಡಿಸಿ

ಪರಿಚಯ

ನೀವು Gemini 2.5 Flash ಅನ್ನು ಸ್ಟ್ರೀಮಿಂಗ್ ಚಾಟ್ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗೆ ಸಂಯೋಜಿಸುವಾಗ, ಕೇವಲ stream=True ಫ್ಲ್ಯಾಗ್ ಸಾಕಾಗುವುದಿಲ್ಲ: Gemini ಎರಡು ವಿಭಿನ್ನ ಟೋಕನ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ — ಚಿಂತನೆಯ (thought) ಟೋಕನ್‌ಗಳು ಮತ್ತು ಪಠ್ಯ (text) ಟೋಕನ್‌ಗಳು — ಮತ್ತು ಅವುಗಳನ್ನು ಒಂದೇ ರೀತಿ ನಿರ್ವಹಿಸಿದರೆ, ತರ್ಕವು ಬಳಕೆದಾರರಿಗೆ ಕಾಣುವ ಚಾಟ್ ಬಬಲ್‌ಗಳಲ್ಲಿ ಸೋರಿಕೆಯಾಗುತ್ತದೆ ಅಥವಾ ಯಾವುದೇ ತರ್ಕದ ಅಗತ್ಯವಿಲ್ಲದ ಪ್ರಶ್ನೆಗಳಲ್ಲಿ ನಿಮ್ಮ ಟೋಕನ್ ಬಿಲ್ ಮೌನವಾಗಿ 2–3× ಹೆಚ್ಚಾಗುತ್ತದೆ. ಎಂಜಿನಿಯರ್‌ಗಳು ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಡಿಪ್ಲಾಯ್ ಮಾಡಿದ ನಂತರವೇ ಕಂಡುಕೊಳ್ಳುತ್ತಾರೆ — ಬಳಕೆದಾರರು ಗೊಂದಲಮಯ ಔಟ್‌ಪುಟ್ ಬಗ್ಗೆ ವರದಿ ಮಾಡಿದಾಗ ಅಥವಾ ಬಿಲ್ಲಿಂಗ್ ಅಲರ್ಟ್‌ಗಳು ಅನಿರೀಕ್ಷಿತವಾಗಿ ಬಂದಾಗ. ಈ ಪಾಠದ ಕೊನೆಯಲ್ಲಿ ನೀವು ಪ್ರತಿ ವಿನಂತಿಗೆ ಒಂದು ThinkingConfig ಅನ್ನು ನಿರ್ಮಿಸಲು, part.thought ಫ್ಲ್ಯಾಗ್ ಬಳಸಿ ಚಿಂತನೆ ಮತ್ತು ಪಠ್ಯ ಟೋಕನ್‌ಗಳ ನಡುವಿನ ಹಂತದ ಗಡಿಯನ್ನು ಪತ್ತೆಹಚ್ಚಲು, ಮತ್ತು ವರ್ಗೀಕರಿಸಿದ ಔಟ್‌ಪುಟ್ ಅನ್ನು FastAPI SSE ಎಂಡ್‌ಪಾಯಿಂಟ್ ಮೂಲಕ ಬ್ರೌಸರ್ EventSource ಕ್ಲೈಂಟ್‌ಗೆ ಸ್ಟ್ರೀಮ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

ಪ್ರಮುಖ ಪರಿಭಾಷೆ

• ThinkingConfig: Gemini 2.5 Flash ನ ವಿಸ್ತೃತ ತರ್ಕ ವರ್ತನೆಯನ್ನು ಪ್ರತಿ ವಿನಂತಿಯ ಆಧಾರದ ಮೇಲೆ ಕಾನ್ಫಿಗರ್ ಮಾಡುವ google.genai.types ಡೇಟಾಕ್ಲಾಸ್; ಇದರ thinking_budget ಫೀಲ್ಡ್, ಮಾಡೆಲ್ ಗೋಚರ ಪಠ್ಯವನ್ನು ಹೊರಡಿಸುವ ಮೊದಲು ತರ್ಕಕ್ಕಾಗಿ ಎಷ್ಟು ಟೋಕನ್‌ಗಳನ್ನು ಖರ್ಚು ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ.
• thinking_budget: ThinkingConfig ಒಳಗೆ ರವಾನಿಸಲಾಗುವ ಒಂದು ಪೂರ್ಣಾಂಕ (0–24576), ಇದು ತರ್ಕದ ಟೋಕನ್‌ಗಳಿಗೆ ಮಿತಿ ಹಾಕುತ್ತದೆ. 0 ಚಿಂತನೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ (ಅತ್ಯಂತ ವೇಗ, ಅತ್ಯಂತ ಅಗ್ಗ); ಹೆಚ್ಚಿನ ಮೌಲ್ಯಗಳು ಬಹು-ಹಂತದ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ನಿಖರತೆಗಾಗಿ ಲೇಟೆನ್ಸಿ ಮತ್ತು ವೆಚ್ಚವನ್ನು ವಿನಿಮಯ ಮಾಡಿಕೊಳ್ಳುತ್ತವೆ.
• SSE (Server-Sent Events): W3C-ಮಾನದಂಡದ ಏಕಮುಖ ಸ್ಟ್ರೀಮಿಂಗ್ ಪ್ರೋಟೋಕಾಲ್, ಇದರಲ್ಲಿ ಸರ್ವರ್ ದೀರ್ಘಕಾಲ ಬದುಕುವ HTTP ಪ್ರತಿಕ್ರಿಯೆಯ ಮೇಲೆ data: <json>\n\n ಫ್ರೇಮ್‌ಗಳನ್ನು ಹೊರಡಿಸುತ್ತದೆ. media_type="text/event-stream" ಜೊತೆಗೆ FastAPI ನ StreamingResponse, Gemini ನ ಎರಡು-ಹಂತದ ಟೋಕನ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಬ್ರೌಸರ್ EventSource ಕ್ಲೈಂಟ್‌ಗೆ ತಲುಪಿಸುವ ಪ್ರಮಾಣಿತ ಮಾರ್ಗವಾಗಿದೆ.

ಪರಿಕಲ್ಪನೆಗಳು

Gemini 2.5 Flash ಸ್ಟ್ರೀಮಿಂಗ್ ಅಡಾಪ್ಟರ್‌ನಲ್ಲಿ ಪ್ರತಿಯೊಂದು ನಿರ್ಧಾರವನ್ನೂ ಎರಡು ಆಲೋಚನೆಗಳು ನಿರ್ದೇಶಿಸುತ್ತವೆ: thinking_budget ಮೌಲ್ಯವು ಪ್ರತಿ ವಿನಂತಿಗೆ ಲೇಟೆನ್ಸಿ–ವೆಚ್ಚ–ನಿಖರತೆಯ ವಿನಿಮಯವನ್ನು ನಿಗದಿಪಡಿಸುತ್ತದೆ, ಮತ್ತು ಪರಿಣಾಮವಾಗಿ ಬರುವ ಪ್ರತಿಕ್ರಿಯೆಯು ಎರಡು-ಹಂತದ ಸ್ಟ್ರೀಮ್ (ಮೊದಲು ಚಿಂತನೆಯ ಟೋಕನ್‌ಗಳು, ನಂತರ ಪಠ್ಯ ಟೋಕನ್‌ಗಳು) ಆಗಿದ್ದು, SSE ಫ್ರೇಮ್‌ಗಳನ್ನು ಹೊರಡಿಸುವ ಮೊದಲು ನಿಮ್ಮ ಸರ್ವರ್ ಅದನ್ನು ವರ್ಗೀಕರಿಸಬೇಕು. ಕೆಳಗಿನ ಉಪವಿಭಾಗವು ಬಜೆಟ್ ಅನ್ನು ಹೇಗೆ ಆಯ್ಕೆ ಮಾಡುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ; ನಂತರ ಕೋಡ್ ವಾಕ್‌ಥ್ರೂ ಹಂತದ ಪರಿವರ್ತನೆಯನ್ನು ಹೇಗೆ ಪತ್ತೆಹಚ್ಚುವುದು ಮತ್ತು ಪ್ರತಿ ಚಂಕ್ ಅನ್ನು ಸರಿಯಾದ SSE ಈವೆಂಟ್ ಪ್ರಕಾರಕ್ಕೆ ಹೇಗೆ ರೂಟ್ ಮಾಡುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.

ಚಿಂತನೆಯ ಬಜೆಟ್ ಆಯ್ಕೆಗಾಗಿ ಪ್ರಾಯೋಗಿಕ ಪರಿಗಣನೆಗಳು

ಸರಿಯಾದ ಚಿಂತನೆಯ ಬಜೆಟ್ ಆಯ್ಕೆ ಮಾಡುವುದು ಲೇಟೆನ್ಸಿ, ವೆಚ್ಚ ಮತ್ತು ಉತ್ತರದ ಗುಣಮಟ್ಟವನ್ನು ಸಮತೋಲನಗೊಳಿಸುವುದನ್ನು ಒಳಗೊಂಡಿದೆ. thinking_budget 0 ಆಗಿದ್ದಾಗ, Gemini 2.5 Flash ತನ್ನ ಚಿಂತನೆ-ರಹಿತ ಪೂರ್ವವರ್ತಿಗೆ ಹೋಲಿಸಬಹುದಾದ ಲೇಟೆನ್ಸಿಯೊಂದಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ — ಸಣ್ಣ ಪ್ರಾಂಪ್ಟ್‌ಗಳಿಗೆ ಸಾಮಾನ್ಯವಾಗಿ 150–300ms ಮೊದಲ-ಟೋಕನ್-ಸಮಯ. thinking_budget=1024 ನಲ್ಲಿ, ಮೊದಲ ಗೋಚರ ಟೋಕನ್ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಮೊದಲು ಮಾಡೆಲ್ ಕೆಲವು ನೂರು ಮಿಲಿಸೆಕೆಂಡುಗಳನ್ನು ತರ್ಕಕ್ಕೆ ಖರ್ಚು ಮಾಡುತ್ತದೆ, ಇದು ಗಮನಾರ್ಹ ವಿಳಂಬವನ್ನು ಸೇರಿಸುತ್ತದೆ ಆದರೆ ಬಹು-ಹಂತದ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ನಿಖರತೆಯನ್ನು ಅರ್ಥಪೂರ್ಣವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ. thinking_budget=8192 ಅಥವಾ ಹೆಚ್ಚಿನದರಲ್ಲಿ, ಪಠ್ಯ ಟೋಕನ್‌ಗಳು ಹರಿಯಲು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ನೀವು 2–5 ಸೆಕೆಂಡುಗಳ "ಚಿಂತನೆಯ" ಮೌನವನ್ನು ಗಮನಿಸಬಹುದು, ಇದಕ್ಕಾಗಿ ಬಳಕೆದಾರರನ್ನು ಗೊಂದಲಗೊಳಿಸದಂತೆ ನಿಮ್ಮ ಫ್ರಂಟ್‌ಎಂಡ್ "ತರ್ಕಿಸುತ್ತಿದೆ..." ಸೂಚಕವನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕಾಗುತ್ತದೆ.

ಚಿಂತನೆಯ ಬಜೆಟ್ ಟೋಕನ್ ಬಿಲ್ಲಿಂಗ್ ಮೇಲೂ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ. ಚಿಂತನೆಯ ಟೋಕನ್‌ಗಳು ನಿಮ್ಮ ಔಟ್‌ಪುಟ್ ಟೋಕನ್ ಬಳಕೆಯಲ್ಲಿ ಎಣಿಕೆಯಾಗುತ್ತವೆ, ಹಾಗಾಗಿ ತನ್ನ ಬಜೆಟ್ ಅನ್ನು ಪೂರ್ಣವಾಗಿ ಬಳಸಿಕೊಳ್ಳುವ thinking_budget=8192 ಹೊಂದಿರುವ ವಿನಂತಿಯು, ಚಿಂತನೆ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿದ ಅದೇ ವಿನಂತಿಗಿಂತ ಸುಮಾರು 2–3x ಹೆಚ್ಚು ವೆಚ್ಚವಾಗುತ್ತದೆ. ಅದಕ್ಕಾಗಿಯೇ ಪ್ರತಿ-ವಿನಂತಿ ನಿಯಂತ್ರಣ ಮುಖ್ಯವಾಗುತ್ತದೆ: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಸರಳ ಪ್ರಶ್ನೆಗಳನ್ನು (ಶುಭಾಶಯಗಳು, ವಾಸ್ತವಾಂಶ ಹುಡುಕಾಟಗಳು) thinking_budget=0 ಜೊತೆಗೆ ಅಡಾಪ್ಟರ್ ಮೂಲಕ ರೂಟ್ ಮಾಡಬಹುದು ಮತ್ತು ಸಂಕೀರ್ಣ ಪ್ರಶ್ನೆಗಳನ್ನು (ಕೋಡ್ ಡೀಬಗ್ಗಿಂಗ್, ಬಹು-ಹಂತದ ಗಣಿತ, ಯೋಜನಾ ಕಾರ್ಯಗಳು) ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಹೆಚ್ಚಿನ ಬಜೆಟ್‌ಗಳಿಗೆ ಏರಿಸಬಹುದು.

ಚಿಂತನೆ ಸಕ್ರಿಯವಾಗಿದ್ದಾಗ, Gemini API ಯಾವುದೇ ಸ್ಪಷ್ಟ temperature ಮೌಲ್ಯವನ್ನು ತಿರಸ್ಕರಿಸುತ್ತದೆ: ನೀವು ಶೂನ್ಯವಲ್ಲದ ಚಿಂತನೆಯ ಬಜೆಟ್ ಜೊತೆಗೆ temperature=0.3 ಅನ್ನು ರವಾನಿಸಿದರೆ, API ನಿಮ್ಮ ಮೌಲ್ಯವನ್ನು ಅನ್ವಯಿಸುವ ಬದಲು ವ್ಯಾಲಿಡೇಶನ್ ದೋಷವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಅದಕ್ಕಾಗಿಯೇ thinking_budget ಶೂನ್ಯಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿದ್ದಾಗಲೆಲ್ಲಾ ಅಡಾಪ್ಟರ್ temperature ಫೀಲ್ಡ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ, ಮತ್ತು thinking_budget=0 ಆಗಿರುವ ಚಿಂತನೆ-ರಹಿತ ಮಾರ್ಗದಲ್ಲಿ ಮಾತ್ರ temperature=1.0 ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ. ಈ ರೀತಿ temperature ಅನ್ನು ಷರತ್ತುಬದ್ಧವಾಗಿ ಹೊಂದಿಸುವುದರಿಂದ ಎರಡೂ ಕೋಡ್ ಮಾರ್ಗಗಳು ಮಾನ್ಯವಾಗಿ ಉಳಿಯುತ್ತವೆ ಮತ್ತು ವಿನಂತಿ ವಿಫಲವಾಗುವುದನ್ನು ತಡೆಯುತ್ತದೆ.

ಕೋಡ್ ವಾಕ್‌ಥ್ರೂ

thinking_budget ಲೇಟೆನ್ಸಿ–ವೆಚ್ಚ–ನಿಖರತೆಯ ವಿನಿಮಯವನ್ನು ಹೇಗೆ ನಿಯಂತ್ರಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಈಗ ನೀವು ಅರ್ಥಮಾಡಿಕೊಂಡಿರುವುದರಿಂದ, ಅನುಷ್ಠಾನವು ಎರಡು ಕಾರ್ಯಗಳಿಗೆ ಸಂಕ್ಷಿಪ್ತಗೊಳ್ಳುತ್ತದೆ: ಪ್ರತಿ ಚಂಕ್‌ನ part.thought ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿ ಅದನ್ನು ಚಿಂತನೆಯ ಟೋಕನ್ ಅಥವಾ ಗೋಚರ ಟೋಕನ್ ಎಂದು ವರ್ಗೀಕರಿಸುವ ಅಡಾಪ್ಟರ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು, ನಂತರ ಆ ಅಡಾಪ್ಟರ್ ಅನ್ನು media_type="text/event-stream" ಜೊತೆಗೆ FastAPI StreamingResponse ಗೆ ಜೋಡಿಸುವುದು.

ಅಡಾಪ್ಟರ್: adapters/gemini_stream.py

GeminiStreamAdapter ಕ್ಲಾಸ್ ಒಂದು google.genai.Client ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು stream_chat ಜನರೇಟರ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ಅದರೊಳಗೆ, ವಿನಂತಿಸಿದ ಬಜೆಟ್‌ಗೆ ಹೊಂದಿಸಲಾದ ThinkingConfig ಜೊತೆಗೆ ಒಂದು GenerateContentConfig ಅನ್ನು ನಿರ್ಮಿಸಲಾಗುತ್ತದೆ. ಒಂದು ಪ್ರಮುಖ ನಿರ್ಬಂಧ: thinking_budget ಶೂನ್ಯಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿದ್ದಾಗ temperature ಫೀಲ್ಡ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಡಬೇಕು — ಎರಡನ್ನೂ ಹೊಂದಿಸಿದರೆ API ವ್ಯಾಲಿಡೇಶನ್ ದೋಷವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. thinking_budget 0 ಆಗಿದ್ದಾಗ, temperature=1.0 ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಹೊಂದಿಸುವುದರಿಂದ ಪ್ರತಿಕ್ರಿಯೆಯ ಶೈಲಿ ಚಿಂತನೆ-ರಹಿತ ಮಾರ್ಗದೊಂದಿಗೆ ಸ್ಥಿರವಾಗಿ ಉಳಿಯುತ್ತದೆ. ಇಟರೇಶನ್ ಲೂಪ್‌ನ ಒಳಗೆ, part.thought ಹಂತದ ಗಡಿಯನ್ನು ಗುರುತಿಸುವ ಫ್ಲ್ಯಾಗ್ ಆಗಿದೆ: ತರ್ಕದ ಹಂತದಲ್ಲಿ True, ಗೋಚರ ಪಠ್ಯ ಪ್ರಾರಂಭವಾದ ನಂತರ False.

Code snippetpython
1from google import genai
2from google.genai import types
3
4class GeminiStreamAdapter:
5    def __init__(self, api_key: str, model: str = "gemini-2.5-flash"):
6        self.client = genai.Client(api_key=api_key)
7        self.model = model
8
9    def stream_chat(self, message: str, thinking_budget: int = 0):
10        """Yields SSE-ready dicts: type='thinking'|'token'|'done'."""
11        config_kwargs: dict = {
12            "thinking_config": types.ThinkingConfig(thinking_budget=thinking_budget),
13        }
14        if thinking_budget == 0:
15            config_kwargs["temperature"] = 1.0
16        config = types.GenerateContentConfig(**config_kwargs)
17        for chunk in self.client.models.generate_content_stream(
18            model=self.model, contents=message, config=config
19        ):
20            for part in chunk.candidates[0].content.parts:
21                if part.thought:
22                    yield {"type": "thinking", "token": part.text}
23                else:
24                    yield {"type": "token", "token": part.text}
25        yield {"type": "done"}

FastAPI SSE ಎಂಡ್‌ಪಾಯಿಂಟ್

ಎಂಡ್‌ಪಾಯಿಂಟ್ stream_chat ಅನ್ನು ಒಂದು async ಜನರೇಟರ್‌ನಲ್ಲಿ ಸುತ್ತಿ ಅದನ್ನು StreamingResponse ಗೆ ರವಾನಿಸುತ್ತದೆ. ಪ್ರತಿ yield ಮಾಡಿದ dict ಅನ್ನು data: …\n\n ಫ್ರೇಮ್‌ಗೆ ಸೀರಿಯಲೈಸ್ ಮಾಡಲಾಗುತ್ತದೆ — ಇದು ಬ್ರೌಸರ್ EventSource ಕ್ಲೈಂಟ್ ಸ್ವಾಭಾವಿಕವಾಗಿ ಓದುವ W3C SSE ವೈರ್ ಫಾರ್ಮ್ಯಾಟ್. thinking_budget ಕ್ವೆರಿ ಪ್ಯಾರಾಮೀಟರ್ ವಿನಂತಿಯಿಂದ ನೇರವಾಗಿ ಹರಿಯುತ್ತದೆ, ಹಾಗಾಗಿ ಕರೆ ಮಾಡುವವರು ರೂಟ್ ಅನ್ನು ಬದಲಾಯಿಸದೆ ತರ್ಕವನ್ನು ಆನ್ ಅಥವಾ ಆಫ್ ಮಾಡಬಹುದು.

Code snippetpython
1import json
2from fastapi import FastAPI
3from fastapi.responses import StreamingResponse
4from adapters.gemini_stream import GeminiStreamAdapter
5
6app = FastAPI()
7adapter = GeminiStreamAdapter(api_key="your-api-key")
8
9@app.post("/chat/stream")
10async def chat_stream(message: str, thinking_budget: int = 0):
11    async def event_generator():
12        for event in adapter.stream_chat(message, thinking_budget):
13            yield f"data: {json.dumps(event)}\n\n"
14
15    return StreamingResponse(event_generator(), media_type="text/event-stream")

POST /chat/stream?message=hello&thinking_budget=0 ಕಳುಹಿಸಿದಾಗ text/event-stream ಪ್ರತಿಕ್ರಿಯೆ ಬರುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ, ಅದರ ಫ್ರೇಮ್‌ಗಳಲ್ಲಿ ಕನಿಷ್ಠ ಒಂದು {"type":"token","token":"..."} ಈವೆಂಟ್ ಇರಬೇಕು ಮತ್ತು ಅಂತಿಮ {"type":"done"} ಫ್ರೇಮ್‌ನೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳಬೇಕು.

ಶಿಸ್ತಿನ ಅನ್ವಯ

ಮಾಡಬೇಕಾದವು ಮತ್ತು ಮಾಡಬಾರದವು

ಮಾಡಬೇಕಾದವು

1. thinking_budget > 0 ಆಗಿದ್ದಾಗಲೆಲ್ಲಾ GenerateContentConfig ನಿಂದ temperature ಅನ್ನು ಬಿಟ್ಟುಬಿಡಿ — ಒಂದೇ ವಿನಂತಿಯಲ್ಲಿ ThinkingConfig ಮತ್ತು temperature ಮೌಲ್ಯ ಎರಡೂ ಇದ್ದರೆ Gemini API ವ್ಯಾಲಿಡೇಶನ್ ದೋಷವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ; ಚಿಂತನೆ-ರಹಿತ ವಿನಂತಿಗಳು ಸ್ಥಿರವಾಗಿ ವರ್ತಿಸುವಂತೆ ಸ್ಪಷ್ಟ temperature=1.0 ನಿಯೋಜನೆಯನ್ನು thinking_budget == 0 ಮಾರ್ಗಕ್ಕೆ ಮಾತ್ರ ಮೀಸಲಿಡಿ.
2. yield ಮಾಡುವ ಮೊದಲು ಟೋಕನ್‌ಗಳನ್ನು ವರ್ಗೀಕರಿಸಲು ಪ್ರತಿ ಚಂಕ್‌ನ ಪ್ರತಿ ಭಾಗದಲ್ಲಿ part.thought ಅನ್ನು ಪರಿಶೀಲಿಸಿ — Gemini 2.5 Flash ಚಿಂತನೆಯ ಟೋಕನ್‌ಗಳನ್ನು ಮತ್ತು ಗೋಚರ ಪಠ್ಯ ಟೋಕನ್‌ಗಳನ್ನು ಒಂದೇ ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ ಬೆರೆಸುತ್ತದೆ, ಮತ್ತು ಅವುಗಳನ್ನು ಪ್ರತ್ಯೇಕ SSE ಈವೆಂಟ್ ಪ್ರಕಾರಗಳಿಗೆ ("thinking" vs "token") ರೂಟ್ ಮಾಡುವುದೇ ಕಚ್ಚಾ ತರ್ಕವು ಬಳಕೆದಾರರಿಗೆ ಕಾಣುವ ಚಾಟ್ ಬಬಲ್‌ನಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುವುದನ್ನು ತಡೆಯುವ ಏಕೈಕ ಮಾರ್ಗ.
3. StreamingResponse ನಲ್ಲಿ media_type="text/event-stream" ಅನ್ನು ಹೊಂದಿಸಿ ಮತ್ತು yield ಮಾಡಿದ ಪ್ರತಿ dict ಅನ್ನು data: …\n\n ಫ್ರೇಮ್ ಆಗಿ ಸೀರಿಯಲೈಸ್ ಮಾಡಿ — ಕಂಟೆಂಟ್-ಟೈಪ್ ಅಥವಾ ಡಬಲ್-ನ್ಯೂಲೈನ್ ಫ್ರೇಮ್ ಡಿಲಿಮಿಟರ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಟ್ಟರೆ W3C SSE ಒಪ್ಪಂದ ಮುರಿಯುತ್ತದೆ ಮತ್ತು ಬ್ರೌಸರ್ EventSource ಕ್ಲೈಂಟ್ ಪ್ರತಿ-ಟೋಕನ್ ಈವೆಂಟ್‌ಗಳನ್ನು ಹೊರಡಿಸುವ ಬದಲು ಅನಿರ್ದಿಷ್ಟವಾಗಿ ಬಫರ್ ಮಾಡುತ್ತದೆ.

ಮಾಡಬಾರದವು

1. Gemini ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಒಂದೇ ಅವಿಭಜಿತ ಟೋಕನ್ ಅನುಕ್ರಮವಾಗಿ ಪರಿಗಣಿಸಬೇಡಿ — part.thought ಅನ್ನು ಪರಿಶೀಲಿಸದೆ chunk.candidates[0].content.parts ಅನ್ನು ಇಟರೇಟ್ ಮಾಡಿದರೆ ಚಿಂತನೆಯ ಟೋಕನ್‌ಗಳು ಮತ್ತು ಗೋಚರ ಟೋಕನ್‌ಗಳು ಒಂದೇ ಸ್ಟ್ರೀಮ್‌ಗೆ ಕುಸಿಯುತ್ತವೆ, ಬಹು-ವಾಕ್ಯದ ತರ್ಕ ಸರಪಳಿಗಳನ್ನು UI ಗೆ ಮೌನವಾಗಿ ಸೋರಿಸುತ್ತದೆ ಮತ್ತು ತರ್ಕ-ಸಕ್ರಿಯ ವಿನಂತಿಗಳಲ್ಲಿ ಬಳಕೆದಾರರಿಗೆ ಕಾಣುವ ಔಟ್‌ಪುಟ್ ಅನ್ನು 2–3× ಹೆಚ್ಚಿಸುತ್ತದೆ.
2. ಒಂದೇ ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಿದ GenerateContentConfig ಅನ್ನು ವಿನಂತಿಗಳಾದ್ಯಂತ ಹಂಚಿಕೊಳ್ಳಬೇಡಿ — ಸ್ಟಾರ್ಟ್‌ಅಪ್‌ನಲ್ಲಿ ಒಮ್ಮೆ config_kwargs ಅನ್ನು ನಿರ್ಮಿಸುವುದರಿಂದ ಕರೆ ಮಾಡುವವರು ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಕ್ವೆರಿ ಪ್ಯಾರಾಮೀಟರ್ ಮೂಲಕ thinking_budget ಅನ್ನು ಟಾಗಲ್ ಮಾಡುವುದನ್ನು ತಡೆಯುತ್ತದೆ; ಪ್ರತಿ ವಿನಂತಿಯು ಸ್ವತಂತ್ರವಾಗಿ ತರ್ಕದ ಹಂತವನ್ನು ಸಕ್ರಿಯ ಅಥವಾ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲು ಸಾಧ್ಯವಾಗುವಂತೆ ThinkingConfig ಅನ್ನು ಪ್ರತಿ ಕರೆಗೆ stream_chat ಒಳಗೆ ನಿರ್ಮಿಸಬೇಕು.
3. SSE ಜನರೇಟರ್‌ನಿಂದ ಅಂತಿಮ {"type": "done"} ಫ್ರೇಮ್ ಅನ್ನು ತ್ಯಜಿಸಬೇಡಿ — ಸ್ಟ್ರೀಮ್ ಸ್ವಚ್ಛವಾಗಿ ಕೊನೆಗೊಂಡಿದೆ ಎಂದು ತಿಳಿಯಲು ಬ್ರೌಸರ್ EventSource ಕ್ಲೈಂಟ್ ಈ ಸೆಂಟಿನೆಲ್ ಅನ್ನು ಅವಲಂಬಿಸಿದೆ; ಅದನ್ನು ಕೈಬಿಟ್ಟರೆ ಕ್ಲೈಂಟ್ ಈಗಾಗಲೇ ಮುಚ್ಚಿದ ಸಂಪರ್ಕವನ್ನು ಪೋಲ್ ಮಾಡುತ್ತಲೇ ಇರುತ್ತದೆ ಮತ್ತು ದೋಷ ಸ್ಥಿತಿಗಳನ್ನು ನಿಧಾನ ಪ್ರತಿಕ್ರಿಯೆಯಿಂದ ಪ್ರತ್ಯೇಕಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.