GenAI DisciplinesFind your levelMatch a JobBytesDocsAbout

Account

Free lesson · GenAI Solutions Architecture

GenAI సాంకేతిక ఎంపికల కోసం ADR schema మరియు decision taxonomy నిర్మించండి

GenAI-నిర్దిష్ట సాంకేతిక ఎంపికలను కవర్ చేసే నిర్మాణాత్మక decision taxonomy తో ఒక ADRSchema ను మీరు నిర్మిస్తారు. MODEL_SELECTION, HOSTING_STRATEGY, RAG_VS_FINETUNING, GUARDRAIL_PLACEMENT, EMBEDDING_PROVIDER, VECTOR_STORE_CHOICE అనే variants తో ఒక DecisionCategory enum ను నిర్వచించండి. ArchitectureDecisionRecord ను ఈ fields తో Pydantic model గా అమలు చేయండి: 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, latency_score, cost_score, quality_score, security_score వంటి criteria ను 0-1 normalized విలువలకు map చేసే scores: dict[str, float], మరియు ప్రతి score కేటాయింపును సమర్థించే URLs లేదా benchmark references ను కలిగి ఉండే evidence: list[str] తో DecisionOption models ను నిర్మించండి. criteria_weights: dict[str, float] ను స్వీకరించి, total_score: float మరియు rank: int fields తో ranked ScoredOption list ను తిరిగి ఇచ్చే compute_weighted_score() ను గణించే WeightedCriteriaMatrix ను అమలు చేయండి. అన్ని weights floating-point tolerance లోపల 1.0 కు కూడికయ్యేలా నిర్ధారించే validate_weights() ను నిర్మించండి; అలా కాకపోతే వివరాలతో InvalidWeightsError ను raise చేయాలి. ADRలను PostgreSQL architecture_decisions table లో ఈ columns తో నిల్వ చేయండి: 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 ను సృష్టించండి. title, category, context, decision అనే అవసరమైన fields తో ADRCreateRequest body ను స్వీకరించి, ఉత్పత్తి చేసిన adr_id మరియు created_at timestamp తో ADRCreateResponse ను తిరిగి ఇచ్చే create_adr() FastAPI endpoint ను POST /api/v1/adrs వద్ద నిర్మించండి. Pagination మరియు filtering మద్దతుతో list_adrs() ను GET /api/v1/adrs?category={cat}&status={status}&page={page} వద్ద అమలు చేయండి. అన్ని supersede links తో సహా పూర్తి version chain ను adr_id, status, created_at, superseded_by కలిగిన ADRVersionEntry objects list గా తిరిగి ఇచ్చే get_adr_history() ను GET /api/v1/adrs/{adr_id}/history వద్ద అమలు చేయండి. ADR సృష్టి రేట్లను ట్రాక్ చేసే adr_versions_total{category,status} Prometheus counter ను, scoring కార్యాచరణను ట్రాక్ చేసే adr_options_evaluated_total{category} counter ను, మరియు endpoint పనితీరును కొలిచే adr_creation_latency_seconds histogram ను deploy చేయండి. పాత ADR ను SUPERSEDED గా atomically గుర్తించి, superseded_by foreign key ద్వారా కొత్తదానితో link చేసే supersede_adr() ను POST /api/v1/adrs/{adr_id}/supersede వద్ద నిర్మించండి; ఏకకాల 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" బ్లాబ్‌లతో మిగిలిపోతాయి, దాంతో సాక్ష్యం వాటికి వ్యతిరేకంగా మారిన చాలా కాలం తర్వాత కూడా అధిగమించబడిన (superseded) మోడల్ ఎంపికలు ప్రొడక్షన్‌లో కొనసాగుతూ ఉంటాయి. ఈ పాఠం ముగిసేసరికి, ప్రతి GenAI ఆర్కిటెక్చర్ నిర్ణయాన్ని మెషీన్-రీడబుల్, ఆడిట్ చేయగలిగేది, మరియు లైవ్ ప్రొడక్షన్ సిగ్నల్‌లకు వ్యతిరేకంగా రివ్యూ చేయగలిగేదిగా చేసే category enum, structured context, criteria-weight matrix, మరియు dependency links కలిగిన typed ADR స్కీమాను మీరు రూపొందించగలరు.

కీలక పదజాలం

  • Architecture Decision Record (ADR): ఆర్కిటెక్చర్ పరంగా ముఖ్యమైన ఒక నిర్ణయాన్ని — దాని సందర్భం, ఎంచుకున్న ఎంపిక, పరిగణించిన ప్రత్యామ్నాయాలు, మరియు దిగువ పరిణామాలు — సంగ్రహించే నిర్మాణాత్మక, నిలిపి ఉంచబడిన డాక్యుమెంట్, దీని ద్వారా భవిష్యత్ రివ్యూయర్లు సిస్టమ్ ఎందుకు ఇలా ఉందో ఆడిట్ చేయగలరు.
  • Decision Taxonomy: ప్రతి ADRను వర్గీకరించే వర్గాల (ఉదా. MODEL_SELECTION, HOSTING_STRATEGY, RAG_VS_FINE_TUNING) నియంత్రిత పదజాలం. దీన్ని enumగా ఎన్‌కోడ్ చేయడం వలన స్కీమా వర్గ-నిర్దిష్ట అవసరమైన ఫీల్డ్‌లను అమలు చేయగలదు మరియు గవర్నెన్స్ క్వెరీలను type-safeగా చేస్తుంది.
  • Telemetry Validator: ADR సృష్టి సమయంలో దానికి బంధించబడిన పేరు గల ప్రొడక్షన్ చెక్ (ఉదా. "p95_latency_under_500ms"). లైవ్ మెట్రిక్స్‌కు వ్యతిరేకంగా ఆ చెక్ విఫలమైనప్పుడు, గవర్నెన్స్ సిస్టమ్ మానవ రివ్యూ అవసరం లేకుండానే ఆ నిర్ణయాన్ని పాతబడినదిగా (stale) ఫ్లాగ్ చేస్తుంది.

భావనలు

కింద ఉన్న రెండు ఆలోచనలు స్కీమా ఆకారాన్ని సమర్థిస్తాయి: మొదటిది, GenAI ఆర్కిటెక్చర్ పనికి ఒక సాధారణ ADR టెంప్లేట్‌ను తిరిగి వాడటం కాకుండా దాని సొంత వర్గ taxonomy ఎందుకు అవసరం, రెండవది, ప్రొడక్షన్‌లో ఆడిట్ చేయగలిగేదిగా ఉండటానికి ADRSchema ఎన్‌కోడ్ చేయవలసిన డిజైన్ సూత్రాలు — స్పష్టమైన criteria weights, బంధించబడిన telemetry validators, enum-typed status, మరియు dependency edges.

GenAI నిర్ణయాలకు కస్టమ్ Taxonomy ఎందుకు అవసరం

Decision taxonomy అనేది ప్రతి ఆర్కిటెక్చర్ నిర్ణయాన్ని బాగా నిర్వచించిన వర్గంలోకి వర్గీకరించే నియంత్రిత పదజాలం. GenAI సిస్టమ్‌లలో, రోజువారీ ఆర్కిటెక్చర్ పనిలో మూడు నిర్ణయ వర్గాలు ప్రధానంగా ఉంటాయి, మరియు ప్రతి ఒక్కటి విభిన్న మూల్యాంకన ప్రమాణాలను కలిగి ఉంటుంది:

  • Model Selection: ఇచ్చిన సామర్థ్యానికి ఏ ఫౌండేషన్ మోడల్ సేవ చేస్తుంది? ఈ నిర్ణయంలో cost-per-token, latency percentiles, క్వాలిటీ బెంచ్‌మార్క్‌లు (MMLU, HumanEval, డొమైన్-నిర్దిష్ట evals), కాంటెక్స్ట్ విండో పరిమాణం, fine-tuning మద్దతు, మరియు vendor lock-in రిస్క్ ఉంటాయి.
  • Hosting Strategy: ఇన్ఫరెన్స్ ఎక్కడ నడుస్తుంది? ఎంపికలు పూర్తిగా-నిర్వహించబడే APIలు (OpenAI, Anthropic, Google), క్లౌడ్-హోస్టెడ్ ఎండ్‌పాయింట్‌లు (SageMaker, Vertex AI, Azure ML), మరియు self-hosted ఇన్‌ఫ్రాస్ట్రక్చర్ (డెడికేటెడ్ GPUలపై vLLM) వరకు విస్తరిస్తాయి. ప్రతి ఎంపిక ఖర్చు నియంత్రణను కార్యాచరణ భారంతో ట్రేడ్-ఆఫ్ చేస్తుంది.
  • RAG vs. Fine-Tuning: సిస్టమ్ డొమైన్ జ్ఞానాన్ని ఎలా చేర్చుకుంటుంది? Retrieval-Augmented Generation బేస్ మోడల్‌ను స్థిరంగా (frozen) ఉంచి క్వెరీ సమయంలో కాంటెక్స్ట్‌ను ఇంజెక్ట్ చేస్తుంది; fine-tuning జ్ఞానాన్ని మోడల్ weightsలో కలిపేస్తుంది. హైబ్రిడ్ విధానాలు రెండింటినీ కలుపుతాయి. ఈ నిర్ణయం డేటా తాజాదనం అవసరాలు, ట్రెయినింగ్ ఇన్‌ఫ్రాస్ట్రక్చర్ లభ్యత, మరియు ఆమోదయోగ్యమైన latency బడ్జెట్‌లపై ఆధారపడి ఉంటుంది.

ఈ మూడు ప్రాథమిక వర్గాలకు మించి, ఒక ప్రొడక్షన్ taxonomyకి guardrail strategy (కంటెంట్ ఫిల్టరింగ్ విధానం), embedding model selection (వెక్టర్ ప్రాతినిధ్య ఎంపికలు), మరియు orchestration pattern (single-call vs. agent loop vs. chain-of-thought pipeline) కోసం కూడా వర్గాలు అవసరం. ఉన్న రికార్డులను విచ్ఛిన్నం చేయకుండా వీటిని చేర్చుకోగలిగేలా స్కీమా విస్తరించదగినదిగా ఉండాలి.

ప్రొడక్షన్ ADR స్కీమాల కోసం డిజైన్ సూత్రాలు

ఈ స్కీమా డిజైన్ నుండి GenAI వర్క్‌లోడ్‌లను లక్ష్యంగా చేసుకున్న ఏ ADR సిస్టమ్‌కైనా విస్తృతంగా వర్తించే అనేక సూత్రాలు వెలువడుతాయి:

  1. వర్గ-నిర్దిష్ట invariantsను క్వెరీ సమయంలో కాకుండా సృష్టి సమయంలో అమలు చేయండి. సిస్టమ్‌లోకి ప్రవేశించే తప్పుగా రూపొందించబడిన ADR డిపెండెన్సీ గ్రాఫ్‌లను కలుషితం చేస్తుంది, గవర్నెన్స్ డ్యాష్‌బోర్డ్‌లను వక్రీకరిస్తుంది, మరియు శుభ్రపరచడానికి లొంగదు. validate మెథడ్ మరియు build_category_context ఫ్యాక్టరీ సమస్యలను నిలిపి ఉంచే (persistence) ముందే పట్టుకుంటాయి.

  2. Criteria weightsను స్పష్టంగా మరియు normalized గా చేయండి. Weighted criteria matrix నేరుగా ADR రికార్డులో పొందుపరచబడినప్పుడు, ఏ రివ్యూయర్ అయినా ఖర్చు, latency, మరియు క్వాలిటీ ఎలా సమతుల్యం చేయబడ్డాయో ఖచ్చితంగా చూడగలరు. Weights మొత్తం 1.0కి సమానం కావాలని నిర్బంధించడం, ఉన్న ప్రమాణాలను తిరిగి సమతుల్యం చేయకుండా కొత్త ప్రమాణాన్ని జోడించే సాధారణ తప్పును నివారిస్తుంది.

  3. Telemetry validatorsను సృష్టి సమయంలోనే నిర్ణయాలకు బంధించండి. telemetry_validators ఫీల్డ్ ఈ నిర్ణయం యొక్క ఊహలను ధృవీకరించే నిర్దిష్ట ప్రొడక్షన్ చెక్‌ల (ఉదా., "p95_latency_under_500ms", "cost_per_request_under_0.02") పేర్లను పేర్కొంటుంది. Validatorsను ముందుగానే ప్రకటించినప్పుడు, telemetry validation సిస్టమ్ మానవ జోక్యం లేకుండా పాతబడిన నిర్ణయాలను స్వయంచాలకంగా గుర్తించగలదు.

  4. Status transitionsను string గా కాకుండా enum గా మోడల్ చేయండి. ఫ్రీ-టెక్స్ట్ status విలువలకు బదులుగా ADRStatus వాడటం అక్షర దోషాలను నివారిస్తుంది, గవర్నెన్స్ లాజిక్‌లో సంపూర్ణ pattern matchingను సాధ్యం చేస్తుంది, మరియు status-ఆధారిత క్వెరీలను type-safe గా చేస్తుంది. ఒక నిర్ణయం ACCEPTED అయినా కాదు, లేదా కాకపోయినా — "approved", "active", లేదా "in_effect" వంటి వైవిధ్యాల నుండి ఎలాంటి అస్పష్టత ఉండదు.

  5. మొదటి రోజు నుండే dependency traversal కోసం డిజైన్ చేయండి. dependencies ఫీల్డ్ ADR IDలను strings జాబితాగా నిల్వ చేస్తుంది, నిర్ణయ డిపెండెన్సీ గ్రాఫ్‌లో edgesను సృష్టిస్తుంది. ఒక hosting strategy నిర్ణయం అధిగమించబడినప్పుడు, ఆ hosting environmentను ఊహించిన ప్రతి దిగువ model selection ADR రివ్యూ కోసం ఫ్లాగ్ చేయబడాలి. స్పష్టమైన dependency tracking లేకుండా, ఈ cascading invalidations ప్రొడక్షన్ ఇన్సిడెంట్లు వాటిని బయటపెట్టే వరకు గుర్తించబడకుండా పోతాయి.

ఈ విభాగంలో మీరు నిర్మించిన స్కీమా తర్వాత వచ్చే ప్రతిదానికీ నిర్మాణాత్మక వెన్నెముకగా నిలుస్తుంది: మరో goalలోని weighted scoring engine, మరో goalలోని telemetry validation pipeline, మరో goalలోని dependency graph traversal, మరియు మరో goalలోని governance dashboard. ప్రతి దిగువ సిస్టమ్ ADRSchema ఇన్‌స్టాన్స్‌లను వినియోగిస్తుంది మరియు డేటా క్వాలిటీకి హామీ ఇవ్వడానికి validate మరియు build_category_context అమలు చేసే invariantsపై ఆధారపడుతుంది.

Loading diagram...

కోడ్ వాక్‌త్రూ

పైన ఉన్న decision taxonomy మరియు డిజైన్ సూత్రాలపై నిర్మిస్తూ, కింది Python వాటిని కాంక్రీట్ typesగా అనువదిస్తుంది: DecisionCategory మరియు ADRStatus enums, మరియు validate మరియు is_expired మెథడ్‌లతో ADRSchema dataclass. Typed ADR సిస్టమ్ యొక్క పునాది మీ సంస్థ గుర్తించే ప్రతి నిర్ణయ వర్గాన్ని సంపూర్ణంగా జాబితా చేసే enum, దానితో జతగా ప్రతి ADR రికార్డు ఆకారాన్ని నిర్వచించే dataclass. ADRSchema ప్రతి రికార్డు taxonomy నుండి తీసుకున్న ఒక category, వర్గ-నిర్దిష్ట మెటాడేటా కోసం నిర్మాణాత్మక context డిక్షనరీ, weighted criteria matrix కోసం criteria_weights మ్యాపింగ్, ఈ నిర్ణయాన్ని ఎగువ ADRలతో లింక్ చేసే 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 వర్గాలను, అదనంగా ప్రొడక్షన్ టీమ్‌లకు సాధారణంగా అవసరమయ్యే మూడు విస్తరణ వర్గాలను జాబితా చేస్తుంది, ప్రతి ఒక్కటి serialization కోసం snake_case విలువను నిల్వ చేస్తుంది. ADRStatus PROPOSED నుండి ACCEPTED, SUPERSEDED, DEPRECATED, లేదా REJECTED వరకు పూర్తి జీవితచక్రాన్ని మోడల్ చేస్తుంది. ADRSchema dataclass ఒక రికార్డు కలిగి ఉండే ప్రతి ఫీల్డ్‌ను ప్రకటిస్తుంది, criteria_weights decision matrix మరియు డిప్లాయ్‌మెంట్ తర్వాత నడిచే telemetry_validators సహా. validate మెథడ్ నిర్మాణాత్మక invariantsను అమలు చేస్తుంది — ఖాళీ కాని title మరియు decision, కనీసం ఒక consequence, model-selection ADRల కోసం అవసరమైన context keys, మరియు tolerance లోపల 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 ADRల కోసం, validate() {"model_name", "provider", "use_case"} context.keys() యొక్క subset గా ఉందో లేదో తనిఖీ చేస్తుంది మరియు ఏదైనా లోపిస్తే ValueError లేవనెత్తుతుంది; ఇక్కడ నిర్మాణాత్మక మెటాడేటాను అందించడమే మోడల్ నిర్ణయాలను ఫ్రీ-టెక్స్ట్ బ్లాబ్‌లుగా కాకుండా క్వెరీ చేయగలిగేవిగా మరియు diff చేయగలిగేవిగా చేస్తుంది.
  2. criteria_weights విలువలు validate() అమలు చేసే 0.01 tolerance లోపల 1.0కి సమానమయ్యేలా చూసుకోండి — మెథడ్ sum(criteria_weights.values()) లెక్కిస్తుంది మరియు [0.99, 1.01] వెలుపల ఉన్న ఏ మొత్తాన్నైనా తిరస్కరిస్తుంది; నిశ్శబ్దంగా జారిపోయే weights dict (ఉదా., రెండు ప్రమాణాలు ప్రతి ఒక్కటి 0.6 వద్ద) రికార్డు ఎప్పటికీ ACCEPTED statusకు చేరకుండా అడ్డుకుంటుంది మరియు నిర్ణయ హేతువు స్పష్టంగా ఉండేలా బలవంతం చేస్తుంది.
  3. review_by datetime సెట్ చేయండి మరియు telemetry_validatorsను నిజమైన ప్రొడక్షన్ చెక్‌లకు బంధించండి — review_by None అయినప్పుడు is_expired() ఎప్పుడూ False ఇస్తుంది, దాంతో గవర్నెన్స్ డ్యాష్‌బోర్డ్‌లు పాతబడిన నిర్ణయాలను ఎప్పటికీ బయటపెట్టలేవు; రెండు ఫీల్డ్‌లూ నింపకపోతే, సాక్ష్యం వ్యతిరేకంగా మారిన MODEL_SELECTION లేదా RAG_VS_FINE_TUNING ADR supersessionను ట్రిగ్గర్ చేయకుండా దాని ACCEPTED statusను నిరవధికంగా కొనసాగిస్తుంది.

చేయకూడనివి

  1. DecisionCategoryను విస్తరించడానికి బదులుగా కొత్త నిర్ణయ రకాన్ని contextలో ఫ్రీ-టెక్స్ట్ ఎంట్రీగా వ్యక్తపరచకండి — DecisionCategory enum సభ్యుడు కాని (ఉదా., HOSTING_STRATEGY, EMBEDDING_MODEL) ప్రతి వర్గం typed taxonomy వెలుపల ఉంటుంది, దాంతో దాన్ని వర్గం ద్వారా ఫిల్టర్ చేయలేం, dependencies ద్వారా ఆధారపడలేం, లేదా ప్రోగ్రామాటిక్‌గా అధిగమించలేం — స్కీమా తొలగించడానికే ఉన్న క్వెరీ చేయలేని ఫ్రీ-టెక్స్ట్ బ్లాబ్‌లను ఖచ్చితంగా పునరుత్పత్తి చేస్తుంది.
  2. ADR ఫలితం ఎగువ నిర్ణయంపై నిర్మితమైనప్పుడు dependencies: list[str]ను ఖాళీగా వదలకండి — ఈ ఫీల్డ్ దిగువ ADRలను అవి ఆధారపడే రికార్డులతో లింక్ చేసే adr_id strings కలిగి ఉంటుంది; దాన్ని వదిలేయడం అంటే నిర్దిష్ట EMBEDDING_MODEL లేదా HOSTING_STRATEGY ఎంపికపై ఆధారపడిన RAG_VS_FINE_TUNING ADRకు మెషీన్-రీడబుల్ లింక్ ఉండదు, దాంతో ఎగువ రికార్డును అధిగమించడం అనాథ, చెల్లని నిర్ణయాలను నిశ్శబ్దంగా యాక్టివ్‌గా వదిలేస్తుంది.
  3. validate()లో ValueErrorను తప్పించుకోవడానికి consequences నింపడాన్ని దాటవేయకండి — self.consequences ఖాళీగా ఉంటే validate() స్పష్టంగా raise చేస్తుంది, మరియు ఈ ఫీల్డ్ 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 →