Gemini API ಅನ್ನು ಕರೆದು ರಚನಾತ್ಮಕ (structured) ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವ Python ಆ್ಯಪ್ ಬರೆಯಿರಿ

ಪರಿಚಯ

ನೀವು ಮೊದಲ ಬಾರಿಗೆ Python ಸೇವೆಯನ್ನು Gemini API ಗೆ ಜೋಡಿಸುವಾಗ, API ಕೀಯನ್ನು ಒಂದು constant ನಲ್ಲಿ ಹಾಕಿ, ರಿಕ್ವೆಸ್ಟ್ ಅನ್ನು ನಿಮ್ಮ route handler ನಲ್ಲಿ ಅಂಟಿಸಿ, ಶಿಪ್ ಮಾಡುವ ಪ್ರಲೋಭನೆ ಉಂಟಾಗುತ್ತದೆ. ಅದು ಒಂದು ಬಾರಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ — ನೀವು ಅದನ್ನು ಡಿಪ್ಲಾಯ್ ಮಾಡಬೇಕಾಗುವವರೆಗೆ. ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಿದ ಸೀಕ್ರೆಟ್‌ಗಳು ನೀವು ಕಂಟೈನರೈಸ್ ಮಾಡಿದ ಕ್ಷಣವೇ ಮುರಿಯುತ್ತವೆ, ತಾತ್ಕಾಲಿಕ error handling ಪ್ರತಿ Gemini ಅಡಚಣೆಯನ್ನೂ 500 ನಂತೆ ಕಾಣಿಸುತ್ತದೆ, ಮತ್ತು ಪ್ರತಿ-ರಿಕ್ವೆಸ್ಟ್ client init ಪ್ರತಿ ಕರೆಯಲ್ಲೂ latency ವ್ಯಯಿಸುತ್ತದೆ. ಈ ಶಿಸ್ತನ್ನು ಬಿಟ್ಟುಬಿಡುವ ತಂಡಗಳು ಕೀ ತಿರುಗಿಸಲು ಇಮೇಜ್ ಅನ್ನು ಮರು-ನಿರ್ಮಿಸಬೇಕಾಗುತ್ತದೆ ಮತ್ತು ಸ್ಥಿರವಾದ error ಆಕಾರವಿಲ್ಲದ ಮಧ್ಯಂತರ ವೈಫಲ್ಯಗಳನ್ನು ಹಿಂಬಾಲಿಸುತ್ತಾ ಕಾಲ ಕಳೆಯುತ್ತವೆ.

ಈ ಪಾಠದ ಕೊನೆಗೆ, ನೀವು environment variables ನಿಂದ ತನ್ನ Gemini ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವ, FastAPI ನ lifespan hook ಮೂಲಕ client ಅನ್ನು ನಿಖರವಾಗಿ ಒಂದೇ ಬಾರಿ initialize ಮಾಡುವ, Gemini API ಗೆ prompt ಗಳನ್ನು ಕಳುಹಿಸುವ, ಮತ್ತು ಊಹಿಸಬಹುದಾದ error semantics ಹೊಂದಿರುವ structured JSON ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವ Python ಅಪ್ಲಿಕೇಶನ್ ಬರೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ — ಮುಂದಿನ ಪಾಠದಲ್ಲಿ ಕಂಟೈನರ್‌ಗೆ ಹಾಕಲು ಸಿದ್ಧವಾಗಿ.

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

• Gemini API — Gemini ಕುಟುಂಬದ ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳಿಗಾಗಿ Google ನ HTTPS endpoint. ಈ ಪಾಠದ ಅಪ್ಲಿಕೇಶನ್ ಇದಕ್ಕೆ prompt ಕಳುಹಿಸಿ ಉತ್ಪಾದಿಸಿದ ಪಠ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ; ಇದರ request/response ಆಕಾರವನ್ನು ತಿಳಿದಿರುವುದೇ ಕೆಳಗಿನ wrapper ಕೋಡ್ ಅರ್ಥಪೂರ್ಣವಾಗಿಸುತ್ತದೆ.
• google-generativeai — Gemini HTTP API ಅನ್ನು ಸುತ್ತುವರಿಯುವ ಅಧಿಕೃತ Python SDK, prompt-ಒಳಗೆ / ಪಠ್ಯ-ಹೊರಗೆ ಕರೆಗಳಿಗಾಗಿ GenerativeModel.generate_content ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ಕೆಳಗಿನ GeminiClient ಕ್ಲಾಸ್ ಇದರ ಮೇಲಿನ ಒಂದು ತೆಳುವಾದ ಪದರ.
• FastAPI — ಬಾಹ್ಯ ಕರೆಗಾರರು Gemini SDK ಯನ್ನು ನೇರವಾಗಿ ಬಳಸದೆ HTTP ಮೂಲಕ prompt ಗಳನ್ನು ಸಲ್ಲಿಸಬಹುದಾದಂತೆ /generate endpoint ಅನ್ನು ಬಹಿರಂಗಪಡಿಸಲು ಇಲ್ಲಿ ಬಳಸಲಾದ async Python ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್.
• Pydantic BaseSettings — environment variables ನಿಂದ Gemini API ಕೀ, ಮಾದರಿಯ ಹೆಸರು ಮತ್ತು timeout ಅನ್ನು ಓದುವ ಮತ್ತು ಅಗತ್ಯವಿರುವ ಯಾವುದೇ ಮೌಲ್ಯ ಕಾಣೆಯಾಗಿದ್ದರೆ startup ನಲ್ಲೇ ತಕ್ಷಣ ವಿಫಲಗೊಳ್ಳುವ ಕಾನ್ಫಿಗರೇಶನ್ ಲೋಡರ್.
• lifespan context — ಅಪ್ಲಿಕೇಶನ್‌ನ ಜೀವಿತಾವಧಿಯ ಸುತ್ತ setup ಮತ್ತು teardown ಅನ್ನು ಚಲಾಯಿಸುವ FastAPI hook. ಪ್ರತಿ ರಿಕ್ವೆಸ್ಟ್‌ನಲ್ಲೂ ಅಲ್ಲದೆ startup ನಲ್ಲಿ ಒಂದೇ ಬಾರಿ Gemini client ಅನ್ನು ನಿರ್ಮಿಸಲು ಇಲ್ಲಿ ಬಳಸಲಾಗಿದೆ.

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

ಪದರಗಳ ವಾಸ್ತುಶಿಲ್ಪ

ಸೇವೆಯು ಮೂರು ಪದರಗಳಾಗಿ ವಿಭಜನೆಗೊಳ್ಳುತ್ತದೆ, ಪ್ರತಿಯೊಂದಕ್ಕೂ ತನ್ನದೇ ಆದ ಕಾನ್ಫಿಗರೇಶನ್ ಜವಾಬ್ದಾರಿ ಇದೆ. FastAPI HTTP ಮತ್ತು Pydantic validation ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ; GeminiClient ಕ್ಲಾಸ್ API ಸಂವಹನ ಮತ್ತು error ಅನುವಾದವನ್ನು ಹೊಂದಿದೆ; Settings ಮಾಡ್ಯೂಲ್ environment variables ನಿಂದ ಕಾನ್ಫಿಗರೇಶನ್ ಲೋಡ್ ಮಾಡುತ್ತದೆ. ಈ ಪ್ರತ್ಯೇಕತೆಯು ಸೀಕ್ರೆಟ್ (API ಕೀ) ಅನ್ನು ರಿಕ್ವೆಸ್ಟ್-ನಿರ್ವಹಣೆ ತರ್ಕದಿಂದ ಬೇರ್ಪಡಿಸುತ್ತದೆ, ಮತ್ತು ಕೋಡ್ ಮುಟ್ಟದೆ ಕರೆಯ ಆಕಾರವನ್ನು (timeout, max tokens) ಹೊಂದಿಸಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ.

validation ಇನ್‌ಪುಟ್ ಅನ್ನು ತಿರಸ್ಕರಿಸಿದರೆ — prompt ಕಾಣೆಯಾಗಿದ್ದರೆ, ಖಾಲಿ string ಆಗಿದ್ದರೆ, prompt ಮಿತಿಯನ್ನು ಮೀರಿದ್ದರೆ — ಯಾವುದೇ Gemini ಕರೆ ಮಾಡುವ ಮೊದಲೇ FastAPI 422 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದು quota ಬಳಕೆಯನ್ನು ಊಹಿಸಬಹುದಾದಂತೆ ಇರಿಸುತ್ತದೆ.

Environment Variables ಮೂಲಕ ಕಾನ್ಫಿಗರೇಶನ್

pydantic_settings ನ BaseSettings ಪ್ರತಿ ಕಾನ್ಫಿಗ್ ಫೀಲ್ಡ್ ಅನ್ನು ಒಂದು type, ಒಂದು default, ಮತ್ತು ಸಂಖ್ಯಾ ವ್ಯಾಪ್ತಿ validators ಜೊತೆ ಘೋಷಿಸುತ್ತದೆ. startup ನಲ್ಲಿ ಇದು environment variables ನಿಂದ ನಿಜವಾದ ಮೌಲ್ಯಗಳನ್ನು ಓದುತ್ತದೆ, development ನಲ್ಲಿ .env ಫೈಲ್‌ಗೆ ಹಿಂತಿರುಗುತ್ತದೆ. ಅಗತ್ಯವಿರುವ ಫೀಲ್ಡ್‌ಗಳು ... ಅನ್ನು ತಮ್ಮ default ಆಗಿ ಬಳಸುತ್ತವೆ, ಹೀಗಾಗಿ GEMINI_API_KEY ಕಾಣೆಯಾದರೆ ಮೊದಲ ರಿಕ್ವೆಸ್ಟ್‌ನಲ್ಲಿ ಅಸ್ಪಷ್ಟ runtime error ಉಂಟುಮಾಡುವ ಬದಲು startup ತಕ್ಷಣವೇ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. (ಕೋಡ್ ವಿವರಣೆ ನೋಡಿ.)

Lifespan-ನಿರ್ವಹಿತ Client Initialization

FastAPI ನ lifespan async context manager ಅಪ್ಲಿಕೇಶನ್‌ನ ಜೀವಿತಾವಧಿಯ ಸುತ್ತ ಒಂದೇ ಬಾರಿ ಚಲಿಸುತ್ತದೆ. ಉದಾಹರಣೆಯು ಇದನ್ನು ಒಂದು GeminiClient ನಿರ್ಮಿಸಿ app.state ನಲ್ಲಿ ಇರಿಸಲು ಬಳಸುತ್ತದೆ. ಪ್ರತಿ ರಿಕ್ವೆಸ್ಟ್ ಆ client ಅನ್ನು — ಮತ್ತು SDK ಯ ಆಧಾರವಾಗಿರುವ connection pool ಅನ್ನು — ಪ್ರತಿ ಕರೆಯಲ್ಲೂ ಮರು-initialize ಮಾಡುವ ಬದಲು ಮರುಬಳಕೆ ಮಾಡುತ್ತದೆ. ಇದರ ಅರ್ಥ credential ವೈಫಲ್ಯಗಳು ಬಳಕೆದಾರರ ಟ್ರಾಫಿಕ್ ಸಮಯದಲ್ಲಿ ಅಲ್ಲದೆ startup ನಲ್ಲೇ ಬೆಳಕಿಗೆ ಬರುತ್ತವೆ.

ಗಡಿಯಲ್ಲಿ Error ಅನುವಾದ

Gemini SDK ನೆಟ್‌ವರ್ಕ್ timeouts, auth ವೈಫಲ್ಯಗಳು ಮತ್ತು rate limits ನಲ್ಲಿ exception ಎಸೆಯಬಹುದು. generate ವಿಧಾನವು ಕರೆಯನ್ನು try/except ನಲ್ಲಿ ಸುತ್ತುವರಿದು HTTPException(502) ಆಗಿ ಮರು-ಎಸೆಯುತ್ತದೆ, ಪ್ರತಿ SDK ವೈಫಲ್ಯ ವಿಧಾನವನ್ನೂ ಒಂದೇ ಊಹಿಸಬಹುದಾದ HTTP ಪ್ರತಿಕ್ರಿಯೆಗೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ. Gemini ಯಾವುದೇ parts ಇಲ್ಲದ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸಿದ ಸಂದರ್ಭವನ್ನು (ಸಾಮಾನ್ಯವಾಗಿ safety-filtered output) ಪ್ರತ್ಯೇಕ guard ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು SDK ಯ ಅಸ್ಪಷ್ಟ ValueError ಬದಲು ಸ್ಪಷ್ಟ ಸಂದೇಶದೊಂದಿಗೆ ಅದೇ 502 ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಕೋಡ್ ವಿವರಣೆ

ಈ ವಿವರಣೆಯು ನಾಲ್ಕು ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಒಟ್ಟಿಗೆ ಪ್ರದರ್ಶಿಸುತ್ತದೆ: BaseSettings ಮೂಲಕ environment-ಚಾಲಿತ ಕಾನ್ಫಿಗರೇಶನ್, lifespan-bootstrapped client initialization, ರಿಕ್ವೆಸ್ಟ್ validation, ಮತ್ತು ಗಡಿಯಲ್ಲಿ error ಅನುವಾದ. ಮೊದಲ snippet Settings ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ; ಎರಡನೆಯದು ಅದನ್ನು GeminiClient ಜೊತೆ FastAPI ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಜೋಡಿಸುತ್ತದೆ.

Code snippetpython
1# settings.py
2from functools import lru_cache
3
4from pydantic import Field
5from pydantic_settings import BaseSettings, SettingsConfigDict
6
7class Settings(BaseSettings):
8    model_config = SettingsConfigDict(env_file=".env", case_sensitive=False)
9
10    gemini_api_key: str = Field(..., description="API key for Gemini")
11    gemini_model: str = Field(default="gemini-1.5-flash")
12    request_timeout: int = Field(default=30, ge=5, le=120)
13    max_output_tokens: int = Field(default=1024, ge=1, le=8192)
14    temperature: float = Field(default=0.7, ge=0.0, le=2.0)
15
16@lru_cache
17def get_settings() -> Settings:
18    return Settings()

gemini_api_key ತನ್ನ default ಆಗಿ ... ಅನ್ನು ಬಳಸುತ್ತದೆ, ಇದು ಅದನ್ನು ಅಗತ್ಯವಾಗಿಸುತ್ತದೆ — GEMINI_API_KEY ಹೊಂದಿಸದಿದ್ದರೆ ಅಪ್ಲಿಕೇಶನ್ startup ನಲ್ಲೇ ತಕ್ಷಣ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. ge/le validators ಅಮಾನ್ಯ ಸಂಖ್ಯಾ ಮೌಲ್ಯಗಳು Gemini ಗೆ ತಲುಪುವ ಮೊದಲೇ ತಡೆಯುತ್ತವೆ. @lru_cache ಪ್ರಕ್ರಿಯೆಯಾದ್ಯಂತ ಒಂದೇ ಹಂಚಿಕೊಂಡ Settings instance ಇರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

Code snippetpython
1# main.py
2from contextlib import asynccontextmanager
3
4import google.generativeai as genai
5from fastapi import FastAPI, HTTPException
6from pydantic import BaseModel, Field
7
8from settings import get_settings
9
10class PromptRequest(BaseModel):
11    prompt: str = Field(..., min_length=1, max_length=10000)
12    temperature: float | None = Field(default=None, ge=0.0, le=2.0)
13
14class GeminiClient:
15    def __init__(self, settings):
16        genai.configure(api_key=settings.gemini_api_key)
17        self._model = genai.GenerativeModel(settings.gemini_model)
18        self._settings = settings
19
20    def generate(self, prompt: str, temperature: float | None = None) -> dict:
21        config = genai.types.GenerationConfig(
22            max_output_tokens=self._settings.max_output_tokens,
23            temperature=temperature or self._settings.temperature,
24        )
25        try:
26            response = self._model.generate_content(
27                prompt,
28                generation_config=config,
29                request_options={"timeout": self._settings.request_timeout},
30            )
31        except Exception as exc:
32            raise HTTPException(status_code=502, detail=str(exc)) from exc
33
34        if not response.parts:
35            raise HTTPException(status_code=502, detail="Empty response from Gemini")
36
37        return {
38            "model": self._settings.gemini_model,
39            "prompt": prompt,
40            "generated_text": response.text,
41        }
42
43@asynccontextmanager
44async def lifespan(app: FastAPI):
45    app.state.client = GeminiClient(get_settings())
46    yield
47
48app = FastAPI(title="Gemini LLM Service", lifespan=lifespan)
49
50@app.post("/generate")
51async def generate_text(request: PromptRequest):
52    return app.state.client.generate(
53        prompt=request.prompt,
54        temperature=request.temperature,
55    )
56
57@app.get("/health")
58async def health_check():
59    return {"status": "healthy"}

PromptRequest ಅಂಚಿನಲ್ಲೇ 1 ರಿಂದ 10,000 ಅಕ್ಷರಗಳ prompt ಅನ್ನು ಜಾರಿಗೊಳಿಸುತ್ತದೆ, ಹೀಗಾಗಿ ಖಾಲಿ ಅಥವಾ ಅತಿ ದೊಡ್ಡ ರಿಕ್ವೆಸ್ಟ್ ಎಂದಿಗೂ Gemini ಗೆ ತಲುಪುವುದಿಲ್ಲ. lifespan context startup ನಲ್ಲಿ GeminiClient ಅನ್ನು ಒಂದೇ ಬಾರಿ ನಿರ್ಮಿಸಿ app.state ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. generate ಒಳಗೆ, try/except ಯಾವುದೇ SDK exception ಅನ್ನು HTTP 502 ಆಗಿ ಅನುವಾದಿಸುತ್ತದೆ, ಮತ್ತು response.parts ಪರಿಶೀಲನೆಯು .text exception ಎಸೆಯುವ ಮೊದಲೇ safety-filtered ಸಂದರ್ಭವನ್ನು ಹಿಡಿಯುತ್ತದೆ. /health endpoint Gemini ಕರೆಯದೆ ಹಿಂತಿರುಗುತ್ತದೆ, ಕಂಟೈನರ್ probes ಗೆ ಅಗ್ಗದ ಗುರಿಯನ್ನು ನೀಡುತ್ತದೆ.

GEMINI_API_KEY ಅನ್ನು export ಮಾಡಿ uvicorn main:app --reload ಚಲಾಯಿಸಿದ ನಂತರ, Content-Type: application/json ಮತ್ತು body {"prompt":"Say hello in one short sentence."} ಜೊತೆ http://localhost:8000/generate ಗೆ POST ಮಾಡಿದಾಗ ಖಾಲಿಯಲ್ಲದ generated_text ಫೀಲ್ಡ್ ಹೊಂದಿರುವ 200 ಹಿಂತಿರುಗಿದರೆ ಅದು ಕೆಲಸ ಮಾಡುತ್ತಿದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿಯುತ್ತದೆ.

ಗಾಗಿ ಪ್ರಾಯೋಗಿಕವಾಗಿ

ಮೇಲಿನ ಮಾದರಿ — environment-ಚಾಲಿತ ಕಾನ್ಫಿಗ್, lifespan-bootstrapped client, ಅಂಚಿನಲ್ಲಿ validation, ಗಡಿಯಲ್ಲಿ error ಅನುವಾದ — ಯಾವುದೇ Gemini-ಆಧಾರಿತ Python ಸೇವೆಗೆ ಅನ್ವಯಿಸುತ್ತದೆ. ನೀವು ಅದನ್ನು ಹೇಗೆ ವಿಸ್ತರಿಸುತ್ತೀರಿ ಎಂಬುದು ನೀವು ಯಾವ ಪಾತ್ರಕ್ಕಾಗಿ ನಿರ್ಮಿಸುತ್ತಿದ್ದೀರಿ ಎಂಬುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ.

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

ಮಾಡಬೇಕಾದವು

1. API ಕೀಯನ್ನು environment variable ನಿಂದ ಲೋಡ್ ಮಾಡಿ — ಸೀಕ್ರೆಟ್ ಅನ್ನು source control ನಿಂದ ಹೊರಗಿಡುತ್ತದೆ ಮತ್ತು ಇಮೇಜ್ ಮರು-ನಿರ್ಮಿಸದೆ ಪ್ರತಿ environment ಗೆ ಕೀಗಳನ್ನು ಬದಲಾಯಿಸಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ.
2. Gemini client ಅನ್ನು lifespan hook ನಲ್ಲಿ ಒಂದೇ ಬಾರಿ initialize ಮಾಡಿ — SDK ಯ connection pool ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡುತ್ತದೆ ಮತ್ತು credential ವೈಫಲ್ಯಗಳನ್ನು ಟ್ರಾಫಿಕ್ ಮಧ್ಯದಲ್ಲಿ ಅಲ್ಲದೆ startup ನಲ್ಲೇ ಬೆಳಕಿಗೆ ತರುತ್ತದೆ.
3. SDK exceptions ಅನ್ನು HTTP 502 ಆಗಿ ಅನುವಾದಿಸಿ — ಆಧಾರವಾಗಿರುವ ಸಮಸ್ಯೆ timeout, auth ವೈಫಲ್ಯ ಅಥವಾ rate limit ಆಗಿದ್ದರೂ ಕರೆಗಾರರಿಗೆ ಒಂದೇ, ಊಹಿಸಬಹುದಾದ ವೈಫಲ್ಯ ವಿಧಾನವನ್ನು ನೀಡುತ್ತದೆ.

ಮಾಡಬಾರದವು

1. API ಕೀ ಅಥವಾ ಮಾದರಿಯ ಹೆಸರನ್ನು ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಬೇಡಿ — ಪ್ರತಿ environment ಬದಲಾವಣೆಯೂ ಇಮೇಜ್ ಮರು-ನಿರ್ಮಾಣವಾಗುತ್ತದೆ, ಮತ್ತು ಸೋರಿಕೆಯಾದ ಇಮೇಜ್ production credentials ಅನ್ನು ಸೋರಿಸುತ್ತದೆ.
2. ಮೊದಲು response.parts ಪರಿಶೀಲಿಸದೆ response.text ಅನ್ನು ಕರೆಯಬೇಡಿ — safety-filtered Gemini ಪ್ರತಿಕ್ರಿಯೆಯು parts ಇಲ್ಲದ ಮಾನ್ಯ ಆಬ್ಜೆಕ್ಟ್ ಆಗಿರುತ್ತದೆ, ಮತ್ತು .text ಅಸ್ಪಷ್ಟ ValueError ಎಸೆಯುತ್ತದೆ.
3. liveness probes ಗಾಗಿ /generate endpoint ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡಬೇಡಿ — ಪ್ರತಿ probe Gemini quota ವ್ಯಯಿಸುತ್ತದೆ; API ಕರೆಯದೆ ಹಿಂತಿರುಗುವ ಪ್ರತ್ಯೇಕ /health route ಅನ್ನು ಬಹಿರಂಗಪಡಿಸಿ.