GenAI DisciplinesFind your levelMatch a JobBytesDocsAbout

Account

Free lesson · GenAI Solutions Architecture

GenAI ટેક્નોલોજી પસંદગીઓ માટે ADR schema અને decision taxonomy બનાવો

તમે GenAI-વિશિષ્ટ ટેક્નોલોજી પસંદગીઓને આવરી લેતી structured decision taxonomy સાથે એક ADRSchema બનાવશો. નીચેના variants સાથે DecisionCategory enum વ્યાખ્યાયિત કરો: MODEL_SELECTION, HOSTING_STRATEGY, RAG_VS_FINETUNING, GUARDRAIL_PLACEMENT, EMBEDDING_PROVIDER, VECTOR_STORE_CHOICE. ArchitectureDecisionRecord ને આ fields સાથે Pydantic model તરીકે implement કરો: adr_id: str, title: str, category: DecisionCategory, status: ADRStatus (PROPOSED, ACCEPTED, SUPERSEDED, DEPRECATED), context: str, decision: str, consequences: list[str], created_at: datetime, superseded_by: Optional[str], decision_makers: list[str], tags: list[str], review_deadline: Optional[datetime], priority: int. option_name: str, provider: str, scores: dict[str, float] (જે latency_score, cost_score, quality_score, security_score જેવા criteria ને 0-1 normalized મૂલ્યો સાથે map કરે છે) અને દરેક score assignment ને સમર્થન આપતા URLs અથવા benchmark references ધરાવતી evidence: list[str] સાથે DecisionOption models બનાવો. WeightedCriteriaMatrix implement કરો જે criteria_weights: dict[str, float] સ્વીકારે છે અને compute_weighted_score() ની ગણતરી કરે છે, જે total_score: float અને rank: int fields સાથે ranked ScoredOption list પરત કરે છે. validate_weights() બનાવો જે ખાતરી કરે કે બધા weights નો સરવાળો floating-point tolerance ની અંદર 1.0 થાય છે, અને જો ન થાય તો વિગતો સાથે InvalidWeightsError raise કરે છે. ADRs ને PostgreSQL ના architecture_decisions table માં આ columns સાથે store કરો: id SERIAL PRIMARY KEY, adr_id VARCHAR(64) UNIQUE NOT NULL, title TEXT NOT NULL, category VARCHAR(32) NOT NULL, status VARCHAR(20) NOT NULL DEFAULT 'PROPOSED', context TEXT, decision TEXT, consequences JSONB, created_at TIMESTAMPTZ DEFAULT NOW(), updated_at TIMESTAMPTZ, superseded_by VARCHAR(64) REFERENCES architecture_decisions(adr_id). option_id SERIAL PRIMARY KEY, adr_id VARCHAR(64) REFERENCES architecture_decisions(adr_id), option_name VARCHAR(128), provider VARCHAR(64), scores JSONB, evidence JSONB સાથે decision_options junction table બનાવો. POST /api/v1/adrs પર create_adr() FastAPI endpoint બનાવો જે જરૂરી fields title, category, context, decision સાથે ADRCreateRequest body સ્વીકારે છે અને generated adr_id તથા created_at timestamp સાથે ADRCreateResponse પરત કરે છે. pagination અને filtering સપોર્ટ સાથે GET /api/v1/adrs?category={cat}&status={status}&page={page} પર list_adrs() implement કરો. GET /api/v1/adrs/{adr_id}/history પર get_adr_history() implement કરો જે બધા supersede links સહિત સંપૂર્ણ version chain ને adr_id, status, created_at, superseded_by સાથે ADRVersionEntry objects ની list તરીકે પરત કરે છે. ADR creation rates ને track કરતો adr_versions_total{category,status} Prometheus counter, scoring activity ને track કરતો adr_options_evaluated_total{category} counter, અને endpoint performance માપતો adr_creation_latency_seconds histogram deploy કરો. POST /api/v1/adrs/{adr_id}/supersede પર supersede_adr() બનાવો જે જૂના ADR ને atomically SUPERSEDED તરીકે mark કરે છે અને નવા ADR ને superseded_by foreign key દ્વારા link કરે છે, તથા concurrent supersede race conditions ને રોકવા માટે SELECT FOR UPDATE સાથે PostgreSQL transaction માં referential integrity લાગુ કરે છે.

Course: GenAI Architecture & Design Patterns · Chapter 1 · GenAI ADR Engine

Free to read — no subscription required.

Continue with Google

પરિચય

જ્યારે તમે પરંપરાગત ADR ટેમ્પલેટને GenAI કોડબેઝમાં કૉપિ કરો છો, ત્યારે ફીલ્ડ્સ લગભગ તરત જ બંધબેસતા બંધ થઈ જાય છે — ટોકન પ્રાઇસિંગ કર્વ્સ માટે કોઈ સ્લોટ નથી, કોન્ટેક્સ્ટ-વિન્ડો મર્યાદાઓ માટે કોઈ ફીલ્ડ નથી, અને કઈ પ્રોડક્શન ટેલિમેટ્રી પાછળથી નિર્ણયને અમાન્ય કરાવવી જોઈએ તે જાહેર કરવા માટે કોઈ જગ્યા નથી. જે ટીમો લેગસી ADR આકારો પર GenAI સિસ્ટમ્સ શિપ કરે છે તેઓ અંતે ફ્રી-ટેક્સ્ટ "decision" બ્લોબ્સ સાથે રહી જાય છે જે ક્વેરી કરવા, ડિપેન્ડન્સી ટ્રેકિંગ અને ઓટોમેટેડ રિવ્યૂનો પ્રતિકાર કરે છે, તેથી પુરાવા તેમની વિરુદ્ધ થઈ ગયા પછી પણ લાંબા સમય સુધી સુપરસીડ થયેલી મોડેલ પસંદગીઓ પ્રોડક્શનમાં ટકી રહે છે. આ પાઠના અંત સુધીમાં તમે એવી ટાઇપ્ડ ADR સ્કીમા ડિઝાઇન કરી શકશો જેનું category enum, સ્ટ્રક્ચર્ડ context, criteria-weight મેટ્રિક્સ અને ડિપેન્ડન્સી લિંક્સ દરેક GenAI આર્કિટેક્ચર નિર્ણયને મશીન-રીડેબલ, ઓડિટેબલ અને લાઇવ પ્રોડક્શન સિગ્નલો સામે રિવ્યૂ કરવા યોગ્ય બનાવે છે.

મુખ્ય પરિભાષા

  • Architecture Decision Record (ADR): એક સ્ટ્રક્ચર્ડ, સાચવેલો દસ્તાવેજ જે આર્કિટેક્ચરની દૃષ્ટિએ મહત્ત્વના નિર્ણયને કેપ્ચર કરે છે — તેનો સંદર્ભ, પસંદ કરેલો વિકલ્પ, વિચારેલા વૈકલ્પિક માર્ગો અને ડાઉનસ્ટ્રીમ પરિણામો — જેથી ભવિષ્યના રિવ્યૂઅર્સ ઓડિટ કરી શકે કે સિસ્ટમ શા માટે આવી દેખાય છે.
  • Decision Taxonomy: શ્રેણીઓની નિયંત્રિત શબ્દાવલી (દા.ત. MODEL_SELECTION, HOSTING_STRATEGY, RAG_VS_FINE_TUNING) જે દરેક ADRનું વર્ગીકરણ કરે છે. તેને enum તરીકે એન્કોડ કરવાથી સ્કીમા શ્રેણી-વિશિષ્ટ જરૂરી ફીલ્ડ્સ લાગુ કરી શકે છે અને ગવર્નન્સ ક્વેરીઓ ટાઇપ-સેફ બને છે.
  • Telemetry Validator: એક નામાંકિત પ્રોડક્શન ચેક (દા.ત. "p95_latency_under_500ms") જે સર્જન સમયે ADR સાથે બાંધવામાં આવે છે. જ્યારે લાઇવ મેટ્રિક્સ સામે આ ચેક નિષ્ફળ જાય છે, ત્યારે ગવર્નન્સ સિસ્ટમ માનવ રિવ્યૂની જરૂર વિના નિર્ણયને જૂનો (stale) તરીકે ફ્લેગ કરે છે.

વિભાવનાઓ

નીચેના બે વિચારો સ્કીમાના આકારને ન્યાયી ઠેરવે છે: પહેલું, GenAI આર્કિટેક્ચર કાર્યને સામાન્ય ADR ટેમ્પલેટનો પુનઃઉપયોગ કરવાને બદલે પોતાની શ્રેણી ટેક્સોનોમીની શા માટે જરૂર છે, અને બીજું, ડિઝાઇન સિદ્ધાંતો — સ્પષ્ટ criteria weights, બાંધેલા telemetry validators, enum-ટાઇપ્ડ status અને ડિપેન્ડન્સી એજિસ — જે ADRSchema એ પ્રોડક્શનમાં ઓડિટેબલ રહેવા માટે એન્કોડ કરવા જ જોઈએ.

GenAI નિર્ણયોને કસ્ટમ ટેક્સોનોમીની શા માટે જરૂર છે

ડિસિઝન ટેક્સોનોમી એ એક નિયંત્રિત શબ્દાવલી છે જે દરેક આર્કિટેક્ચર નિર્ણયને સુ-વ્યાખ્યાયિત શ્રેણીમાં વર્ગીકૃત કરે છે. GenAI સિસ્ટમ્સમાં, ત્રણ નિર્ણય શ્રેણીઓ રોજબરોજના આર્કિટેક્ચર કાર્ય પર પ્રભુત્વ ધરાવે છે, અને દરેક અલગ મૂલ્યાંકન માપદંડો ધરાવે છે:

  • Model Selection: આપેલી ક્ષમતા માટે કયું ફાઉન્ડેશન મોડેલ સેવા આપે છે? આ નિર્ણયમાં cost-per-token, લેટન્સી પર્સન્ટાઇલ્સ, ક્વોલિટી બેન્ચમાર્ક્સ (MMLU, HumanEval, ડોમેન-વિશિષ્ટ evals), કોન્ટેક્સ્ટ વિન્ડો સાઇઝ, ફાઇન-ટ્યુનિંગ સપોર્ટ અને વેન્ડર લોક-ઇન જોખમનો સમાવેશ થાય છે.
  • Hosting Strategy: ઇન્ફરન્સ ક્યાં ચાલે છે? વિકલ્પોમાં સંપૂર્ણ-મેનેજ્ડ APIs (OpenAI, Anthropic, Google), ક્લાઉડ-હોસ્ટેડ એન્ડપોઇન્ટ્સ (SageMaker, Vertex AI, Azure ML) અને સેલ્ફ-હોસ્ટેડ ઇન્ફ્રાસ્ટ્રક્ચર (ડેડિકેટેડ GPUs પર vLLM) નો સમાવેશ થાય છે. દરેક પસંદગી ખર્ચ નિયંત્રણ અને ઓપરેશનલ બોજ વચ્ચે ટ્રેડ-ઓફ કરે છે.
  • RAG vs. Fine-Tuning: સિસ્ટમ ડોમેન જ્ઞાનને કેવી રીતે સમાવે છે? Retrieval-Augmented Generation બેઝ મોડેલને ફ્રોઝન રાખે છે અને ક્વેરી સમયે કોન્ટેક્સ્ટ ઇન્જેક્ટ કરે છે; ફાઇન-ટ્યુનિંગ જ્ઞાનને મોડેલ વેઇટ્સમાં વણી લે છે. હાઇબ્રિડ અભિગમો બંનેને જોડે છે. આ નિર્ણય ડેટા તાજગીની જરૂરિયાતો, ટ્રેનિંગ ઇન્ફ્રાસ્ટ્રક્ચરની ઉપલબ્ધતા અને સ્વીકાર્ય લેટન્સી બજેટ પર આધાર રાખે છે.

આ ત્રણ પ્રાથમિક શ્રેણીઓ ઉપરાંત, પ્રોડક્શન ટેક્સોનોમીને guardrail strategy (કન્ટેન્ટ ફિલ્ટરિંગ અભિગમ), embedding model selection (વેક્ટર રિપ્રેઝન્ટેશન પસંદગીઓ) અને orchestration pattern (સિંગલ-કૉલ વિરુદ્ધ એજન્ટ લૂપ વિરુદ્ધ chain-of-thought પાઇપલાઇન) માટે પણ શ્રેણીઓની જરૂર છે. હાલના રેકોર્ડ્સને તોડ્યા વિના આને સમાવવા માટે સ્કીમા વિસ્તરણક્ષમ હોવી જોઈએ.

પ્રોડક્શન ADR સ્કીમા માટે ડિઝાઇન સિદ્ધાંતો

આ સ્કીમા ડિઝાઇનમાંથી ઘણા સિદ્ધાંતો ઉભરે છે જે GenAI વર્કલોડ્સને લક્ષ્ય બનાવતી કોઈપણ ADR સિસ્ટમ પર વ્યાપકપણે લાગુ પડે છે:

  1. શ્રેણી-વિશિષ્ટ ઇન્વેરિઅન્ટ્સ ક્વેરી સમયે નહીં પણ સર્જન સમયે લાગુ કરો. સિસ્ટમમાં પ્રવેશતો ખામીયુક્ત ADR ડિપેન્ડન્સી ગ્રાફ્સને પ્રદૂષિત કરશે, ગવર્નન્સ ડેશબોર્ડ્સને વિકૃત કરશે અને સફાઈનો પ્રતિકાર કરશે. validate મેથડ અને build_category_context ફેક્ટરી સાચવતા પહેલાં સમસ્યાઓ પકડી લે છે.

  2. Criteria weights સ્પષ્ટ અને નોર્મલાઇઝ્ડ બનાવો. જ્યારે વેઇટેડ criteria મેટ્રિક્સ સીધો ADR રેકોર્ડમાં એમ્બેડ થાય છે, ત્યારે કોઈપણ રિવ્યૂઅર બરાબર જોઈ શકે છે કે ખર્ચ, લેટન્સી અને ગુણવત્તાને કેવી રીતે સંતુલિત કરવામાં આવ્યા હતા. વેઇટ્સનો સરવાળો 1.0 થાય તેવી જરૂરિયાત હાલના criteria ને ફરીથી સંતુલિત કર્યા વિના નવો criterion ઉમેરવાની સામાન્ય ભૂલને અટકાવે છે.

  3. સર્જન સમયે telemetry validators ને નિર્ણયો સાથે બાંધો. telemetry_validators ફીલ્ડ ચોક્કસ પ્રોડક્શન ચેક્સ (દા.ત. "p95_latency_under_500ms", "cost_per_request_under_0.02") ના નામ આપે છે જે આ નિર્ણયની ધારણાઓને માન્ય કરે છે. જ્યારે validators અગાઉથી જાહેર કરવામાં આવે છે, ત્યારે ટેલિમેટ્રી વેલિડેશન સિસ્ટમ માનવ હસ્તક્ષેપ વિના આપોઆપ જૂના નિર્ણયો શોધી શકે છે.

  4. Status ટ્રાન્ઝિશનને string તરીકે નહીં પણ enum તરીકે મોડેલ કરો. ફ્રી-ટેક્સ્ટ status મૂલ્યોને બદલે ADRStatus નો ઉપયોગ કરવાથી ટાઇપો અટકે છે, ગવર્નન્સ લોજિકમાં સંપૂર્ણ પેટર્ન મેચિંગ શક્ય બને છે અને status-આધારિત ક્વેરીઓ ટાઇપ-સેફ બને છે. નિર્ણય કાં તો ACCEPTED છે અથવા નથી—"approved", "active" કે "in_effect" જેવા વેરિએશનથી કોઈ અસ્પષ્ટતા રહેતી નથી.

  5. પહેલા દિવસથી જ ડિપેન્ડન્સી ટ્રાવર્સલ માટે ડિઝાઇન કરો. dependencies ફીલ્ડ ADR IDs ને strings ની યાદી તરીકે સંગ્રહે છે, જે ડિસિઝન ડિપેન્ડન્સી ગ્રાફમાં એજિસ બનાવે છે. જ્યારે હોસ્ટિંગ વ્યૂહરચનાનો નિર્ણય સુપરસીડ થાય છે, ત્યારે તે હોસ્ટિંગ પર્યાવરણની ધારણા કરતો દરેક ડાઉનસ્ટ્રીમ મોડેલ પસંદગી ADR રિવ્યૂ માટે ફ્લેગ થવો જોઈએ. સ્પષ્ટ ડિપેન્ડન્સી ટ્રેકિંગ વિના, આ કાસ્કેડિંગ અમાન્યતાઓ પ્રોડક્શન ઘટનાઓ તેમને સપાટી પર લાવે ત્યાં સુધી ધ્યાન બહાર રહે છે.

આ વિભાગમાં તમે બનાવેલી સ્કીમા આગળ આવનારી દરેક બાબત માટે માળખાકીય કરોડરજ્જુ બનાવે છે: બીજા ધ્યેયમાં વેઇટેડ સ્કોરિંગ એન્જિન, બીજા ધ્યેયમાં ટેલિમેટ્રી વેલિડેશન પાઇપલાઇન, બીજા ધ્યેયમાં ડિપેન્ડન્સી ગ્રાફ ટ્રાવર્સલ અને બીજા ધ્યેયમાં ગવર્નન્સ ડેશબોર્ડ. દરેક ડાઉનસ્ટ્રીમ સિસ્ટમ ADRSchema ઇન્સ્ટન્સનો ઉપયોગ કરે છે અને ડેટા ગુણવત્તાની ખાતરી આપવા માટે validate અને build_category_context દ્વારા લાગુ થતા ઇન્વેરિઅન્ટ્સ પર આધાર રાખે છે.

Loading diagram...

કોડ વૉકથ્રૂ

ઉપરની ડિસિઝન ટેક્સોનોમી અને ડિઝાઇન સિદ્ધાંતો પર આધાર રાખીને, નીચેનો Python તેમને નક્કર ટાઇપ્સમાં રૂપાંતરિત કરે છે: DecisionCategory અને ADRStatus enums, અને તેની validate અને is_expired મેથડ્સ સાથેનો ADRSchema dataclass. ટાઇપ્ડ ADR સિસ્ટમનો પાયો એક enum છે જે તમારી સંસ્થા ઓળખે છે તે દરેક નિર્ણય શ્રેણીની સંપૂર્ણ યાદી આપે છે, જેની સાથે એક dataclass જોડાયેલો છે જે દરેક ADR રેકોર્ડનો આકાર વ્યાખ્યાયિત કરે છે. ADRSchema લાગુ કરે છે કે દરેક રેકોર્ડમાં ટેક્સોનોમીમાંથી લીધેલી category, શ્રેણી-વિશિષ્ટ મેટાડેટા માટે સ્ટ્રક્ચર્ડ context ડિક્શનરી, વેઇટેડ criteria મેટ્રિક્સ માટે criteria_weights મેપિંગ, આ નિર્ણયને અપસ્ટ્રીમ ADRs સાથે જોડતી dependencies અને તેને પ્રોડક્શન ચેક્સ સાથે બાંધતા telemetry_validators હોય.

Code snippetpython
1from dataclasses import dataclass, field
2from enum import Enum
3from datetime import datetime
4from typing import Optional
5import uuid
6
7class DecisionCategory(Enum):
8    MODEL_SELECTION = "model_selection"
9    HOSTING_STRATEGY = "hosting_strategy"
10    RAG_VS_FINE_TUNING = "rag_vs_fine_tuning"
11    GUARDRAIL_STRATEGY = "guardrail_strategy"
12    EMBEDDING_MODEL = "embedding_model"
13    ORCHESTRATION_PATTERN = "orchestration_pattern"
14
15class ADRStatus(Enum):
16    PROPOSED = "proposed"
17    ACCEPTED = "accepted"
18    SUPERSEDED = "superseded"
19    DEPRECATED = "deprecated"
20    REJECTED = "rejected"
21
22@dataclass
23class ADRSchema:
24    title: str
25    category: DecisionCategory
26    context: dict
27    decision: str
28    consequences: list[str]
29    criteria_weights: dict[str, float] = field(default_factory=dict)
30    dependencies: list[str] = field(default_factory=list)
31    alternatives_considered: list[dict] = field(default_factory=list)
32    status: ADRStatus = ADRStatus.PROPOSED
33    adr_id: str = field(default_factory=lambda: f"ADR-{uuid.uuid4().hex[:8]}")
34    created_at: datetime = field(default_factory=datetime.utcnow)
35    review_by: Optional[datetime] = None
36    superseded_by: Optional[str] = None
37    telemetry_validators: list[str] = field(default_factory=list)
38
39    def validate(self) -> bool:
40        if not self.title or not self.decision:
41            raise ValueError("ADR must have both title and decision text")
42        if not self.consequences:
43            raise ValueError("ADR must document at least one consequence")
44        if self.category == DecisionCategory.MODEL_SELECTION:
45            required = {"model_name", "provider", "use_case"}
46            if not required.issubset(self.context.keys()):
47                raise ValueError(f"Model selection ADR requires context keys: {required}")
48        if self.criteria_weights:
49            total = sum(self.criteria_weights.values())
50            if abs(total - 1.0) > 0.01:
51                raise ValueError(f"Criteria weights must sum to 1.0, got {total}")
52        return True
53
54    def is_expired(self) -> bool:
55        if self.review_by is None:
56            return False
57        return datetime.utcnow() > self.review_by

DecisionCategory enum ત્રણ પ્રાથમિક GenAI શ્રેણીઓ ઉપરાંત પ્રોડક્શન ટીમોને સામાન્ય રીતે જરૂરી ત્રણ વિસ્તરણ શ્રેણીઓની યાદી આપે છે, દરેક સીરિયલાઇઝેશન માટે snake_case મૂલ્ય સંગ્રહે છે. ADRStatus સંપૂર્ણ જીવનચક્રને મોડેલ કરે છે, PROPOSED થી ACCEPTED, SUPERSEDED, DEPRECATED અથવા REJECTED સુધી. ADRSchema dataclass રેકોર્ડ ધરાવે છે તે દરેક ફીલ્ડ જાહેર કરે છે, જેમાં criteria_weights ડિસિઝન મેટ્રિક્સ અને ડિપ્લોયમેન્ટ પછી ચાલતા telemetry_validators નો સમાવેશ થાય છે. validate મેથડ માળખાકીય ઇન્વેરિઅન્ટ્સ લાગુ કરે છે — ખાલી ન હોય તેવા title અને decision, ઓછામાં ઓછું એક consequence, model-selection ADRs માટે જરૂરી context keys, અને ટોલરન્સની અંદર 1.0 નો સરવાળો થતા criteria weights — અને કોઈપણ ઉલ્લંઘન પર ValueError રેઇઝ કરે છે. is_expired મેથડ જ્યારે કોઈ review_by ડેડલાઇન સેટ ન હોય ત્યારે False પરત કરે છે અને અન્યથા વર્તમાન UTC સમયની તેની સાથે સરખામણી કરે છે, જેનાથી ગવર્નન્સ ડેશબોર્ડ્સ જૂના નિર્ણયો સપાટી પર લાવી શકે છે. ચકાસવા માટે context keys model_name, provider અને use_case સાથે અને 1.0 નો સરવાળો થતા criteria_weights સાથે MODEL_SELECTION ADR ઇન્સ્ટન્શિયેટ કરો, પછી validate કૉલ કરો — તે True પરત કરે ત્યારે તમને ખબર પડશે કે તે કામ કરે છે, જ્યારે તે keys વગરનું અથવા 0.01 થી વધુ ભૂલવાળા weights ધરાવતું ઇન્સ્ટન્સ ValueError રેઇઝ કરે છે.

શિસ્ત-વિશિષ્ટ ઉપયોગ

શું કરવું અને શું ન કરવું

શું કરવું

  1. validate() કૉલ કરતા પહેલાં context માં જરૂરી શ્રેણી-વિશિષ્ટ keys ભરો — MODEL_SELECTION ADRs માટે, validate() ચકાસે છે કે {"model_name", "provider", "use_case"} એ context.keys() નો સબસેટ છે અને કોઈપણ ખૂટે તો ValueError રેઇઝ કરે છે; અહીં સ્ટ્રક્ચર્ડ મેટાડેટા આપવાથી જ મોડેલ નિર્ણયો ફ્રી-ટેક્સ્ટ બ્લોબ્સને બદલે ક્વેરી કરવા યોગ્ય અને diff કરવા યોગ્ય બને છે.
  2. ખાતરી કરો કે criteria_weights ના મૂલ્યોનો સરવાળો validate() દ્વારા લાગુ થતી 0.01 ટોલરન્સની અંદર 1.0 થાય છે — મેથડ sum(criteria_weights.values()) ગણે છે અને [0.99, 1.01] ની બહારના કોઈપણ કુલને નકારે છે; ચૂપચાપ ભટકી જતો weights dict (દા.ત. બે criteria દરેક 0.6 પર) રેકોર્ડને ક્યારેય ACCEPTED status સુધી પહોંચતા અટકાવશે અને નિર્ણયના તર્કને સ્પષ્ટ રહેવા ફરજ પાડે છે.
  3. review_by datetime સેટ કરો અને telemetry_validators ને વાસ્તવિક પ્રોડક્શન ચેક્સ સાથે બાંધો — જ્યારે review_by એ None હોય ત્યારે is_expired() હંમેશા False પરત કરે છે, તેથી ગવર્નન્સ ડેશબોર્ડ્સ ક્યારેય જૂના નિર્ણયો સપાટી પર લાવી શકતા નથી; બંને ફીલ્ડ ભર્યા વિના, પુરાવા જેની વિરુદ્ધ થઈ ગયા હોય તેવો MODEL_SELECTION અથવા RAG_VS_FINE_TUNING ADR સુપરસેશન ટ્રિગર કરવાને બદલે અનિશ્ચિત સમય સુધી પોતાનો ACCEPTED status જાળવી રાખશે.

શું ન કરવું

  1. DecisionCategory ને વિસ્તારવાને બદલે નવા નિર્ણય પ્રકારને context માં ફ્રી-ટેક્સ્ટ એન્ટ્રી તરીકે વ્યક્ત ન કરો — જે શ્રેણી DecisionCategory enum સભ્ય નથી (દા.ત. HOSTING_STRATEGY, EMBEDDING_MODEL) તે ટાઇપ્ડ ટેક્સોનોમીની બહાર રહે છે, તેથી તેને શ્રેણી દ્વારા ફિલ્ટર કરી શકાતી નથી, dependencies દ્વારા તેના પર આધાર રાખી શકાતો નથી, કે પ્રોગ્રામેટિક રીતે સુપરસીડ કરી શકાતી નથી — જે બરાબર એ જ ક્વેરી ન કરી શકાય તેવા ફ્રી-ટેક્સ્ટ બ્લોબ્સનું પુનરાવર્તન કરે છે જેને દૂર કરવા માટે સ્કીમા અસ્તિત્વમાં છે.
  2. જ્યારે ADRનું પરિણામ અપસ્ટ્રીમ નિર્ણય પર આધારિત હોય ત્યારે dependencies: list[str] ખાલી ન છોડો — આ ફીલ્ડ adr_id strings ધરાવે છે જે ડાઉનસ્ટ્રીમ ADRs ને તેઓ જેના પર આધાર રાખે છે તે રેકોર્ડ્સ સાથે જોડે છે; તેને છોડી દેવાનો અર્થ એ છે કે ચોક્કસ EMBEDDING_MODEL અથવા HOSTING_STRATEGY પસંદગી પર ટકેલા RAG_VS_FINE_TUNING ADR પાસે કોઈ મશીન-રીડેબલ લિંક નથી, તેથી અપસ્ટ્રીમ રેકોર્ડને સુપરસીડ કરવાથી અનાથ, અમાન્ય નિર્ણયો ચૂપચાપ સક્રિય રહી જાય છે.
  3. validate() માં ValueError ટાળવા માટે consequences ભરવાનું ન છોડો — જો self.consequences ખાલી હોય તો validate() સ્પષ્ટપણે રેઇઝ કરે છે, અને આ ફીલ્ડ એ ટેક્સ્ચ્યુઅલ કરાર છે જેને telemetry_validators ડિપ્લોયમેન્ટ પછી ચકાસે છે; consequences વગરના ADR પાસે માપવા માટે કોઈ જાહેર કરેલી આગાહીઓ નથી, જે telemetry_validators ની દરેક એન્ટ્રીને આધાર વિનાની અને રિવ્યૂ ચક્રને અર્થહીન બનાવે છે.

3 hands-on labs come with this lesson — real code, in a cloud IDE. Create a free account to run them. No card.

Continue with GoogleUse email or company SSO instead →

Free account · no card · straight to the labs

Or get the full path — from

Listen to this lesson

Audio overviews of this lesson's labs and its chapter, from GenBodha Bytes.

More free lessons in GenAI Architecture & Design Patterns

All free lessons in GenAI Solutions Architecture →