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 ನಂತಹ ಮಾನದಂಡಗಳನ್ನು 0-1 normalized ಮೌಲ್ಯಗಳಿಗೆ map ಮಾಡುವ scores: dict[str, float], ಮತ್ತು ಪ್ರತಿ score ನಿಯೋಜನೆಯನ್ನು ಬೆಂಬಲಿಸುವ URLಗಳು ಅಥವಾ benchmark ಉಲ್ಲೇಖಗಳನ್ನು ಹೊಂದಿರುವ evidence: list[str] ಇರುವ DecisionOption models ನಿರ್ಮಿಸಿ. criteria_weights: dict[str, float] ಅನ್ನು ಸ್ವೀಕರಿಸಿ, total_score: float ಮತ್ತು rank: int fields ಹೊಂದಿರುವ ಶ್ರೇಣೀಕೃತ ScoredOption ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸುವ compute_weighted_score() ಅನ್ನು ಲೆಕ್ಕಹಾಕುವ WeightedCriteriaMatrix ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ. ಎಲ್ಲಾ weights floating-point tolerance ಒಳಗೆ 1.0 ಗೆ ಸಮನಾಗಿ ಕೂಡುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸುವ, ಇಲ್ಲದಿದ್ದರೆ ವಿವರಗಳೊಂದಿಗೆ InvalidWeightsError ಅನ್ನು raise ಮಾಡುವ validate_weights() ಅನ್ನು ನಿರ್ಮಿಸಿ. 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 ಲಿಂಕ್‌ಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಸಂಪೂರ್ಣ version chain ಅನ್ನು adr_id, status, created_at, superseded_by ಹೊಂದಿರುವ ADRVersionEntry objects ಪಟ್ಟಿಯಾಗಿ ಹಿಂತಿರುಗಿಸುವ get_adr_history() ಅನ್ನು GET /api/v1/adrs/{adr_id}/history ನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಿ. ADR ರಚನೆಯ ದರಗಳನ್ನು track ಮಾಡುವ adr_versions_total{category,status} Prometheus counter, scoring ಚಟುವಟಿಕೆಯನ್ನು track ಮಾಡುವ adr_options_evaluated_total{category} counter, ಮತ್ತು endpoint ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅಳೆಯುವ adr_creation_latency_seconds histogram ಅನ್ನು deploy ಮಾಡಿ. ಹಳೆಯ ADR ಅನ್ನು atomically SUPERSEDED ಎಂದು ಗುರುತಿಸಿ, superseded_by foreign key ಮೂಲಕ ಹೊಸದನ್ನು ಲಿಂಕ್ ಮಾಡುವ, ಮತ್ತು concurrent supersede race conditions ತಡೆಯಲು SELECT FOR UPDATE ಜೊತೆಗೆ PostgreSQL transaction ನಲ್ಲಿ referential integrity ಅನ್ನು ಜಾರಿಗೊಳಿಸುವ supersede_adr() ಅನ್ನು POST /api/v1/adrs/{adr_id}/supersede ನಲ್ಲಿ ನಿರ್ಮಿಸಿ.

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

Free to read — no subscription required.

Continue with Google

ಪರಿಚಯ

ಸಾಂಪ್ರದಾಯಿಕ ADR ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು GenAI ಕೋಡ್‌ಬೇಸ್‌ಗೆ ನಕಲಿಸಿದಾಗ, ಕ್ಷೇತ್ರಗಳು ಬಹುತೇಕ ತಕ್ಷಣವೇ ಹೊಂದಿಕೊಳ್ಳುವುದನ್ನು ನಿಲ್ಲಿಸುತ್ತವೆ — ಟೋಕನ್ ಬೆಲೆ ವಕ್ರರೇಖೆಗಳಿಗೆ ಸ್ಥಳವಿಲ್ಲ, ಕಾಂಟೆಕ್ಸ್ಟ್-ವಿಂಡೋ ಮಿತಿಗಳಿಗೆ ಕ್ಷೇತ್ರವಿಲ್ಲ, ಯಾವ ಪ್ರೊಡಕ್ಷನ್ ಟೆಲಿಮೆಟ್ರಿ ನಂತರ ನಿರ್ಧಾರವನ್ನು ಅಮಾನ್ಯಗೊಳಿಸಬೇಕು ಎಂದು ಘೋಷಿಸಲು ಜಾಗವಿಲ್ಲ. ಹಳೆಯ ADR ಆಕಾರಗಳಲ್ಲಿ GenAI ವ್ಯವಸ್ಥೆಗಳನ್ನು ಶಿಪ್ ಮಾಡುವ ತಂಡಗಳು ಕೊನೆಗೆ ಕ್ವೆರಿ ಮಾಡುವಿಕೆ, ಅವಲಂಬನೆ ಟ್ರ್ಯಾಕಿಂಗ್ ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ ವಿಮರ್ಶೆಯನ್ನು ವಿರೋಧಿಸುವ ಮುಕ್ತ-ಪಠ್ಯ "ನಿರ್ಧಾರ" ಬ್ಲಾಬ್‌ಗಳೊಂದಿಗೆ ಉಳಿಯುತ್ತವೆ, ಹೀಗಾಗಿ ಸಾಕ್ಷ್ಯಗಳು ಅವುಗಳ ವಿರುದ್ಧ ತಿರುಗಿದ ಬಹಳ ಸಮಯದ ನಂತರವೂ ಹಳತಾದ ಮಾಡೆಲ್ ಆಯ್ಕೆಗಳು ಪ್ರೊಡಕ್ಷನ್‌ನಲ್ಲಿ ಉಳಿದುಕೊಳ್ಳುತ್ತವೆ. ಈ ಪಾಠದ ಅಂತ್ಯದ ವೇಳೆಗೆ, ನೀವು ಒಂದು ಟೈಪ್ಡ್ ADR ಸ್ಕೀಮಾವನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ — ಅದರ ವರ್ಗ enum, ರಚನಾತ್ಮಕ ಕಾಂಟೆಕ್ಸ್ಟ್, ಮಾನದಂಡ-ತೂಕ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಮತ್ತು ಅವಲಂಬನೆ ಲಿಂಕ್‌ಗಳು ಪ್ರತಿಯೊಂದು GenAI ಆರ್ಕಿಟೆಕ್ಚರ್ ನಿರ್ಧಾರವನ್ನು ಯಂತ್ರ-ಓದಬಲ್ಲ, ಆಡಿಟ್ ಮಾಡಬಲ್ಲ ಮತ್ತು ಲೈವ್ ಪ್ರೊಡಕ್ಷನ್ ಸಿಗ್ನಲ್‌ಗಳ ವಿರುದ್ಧ ವಿಮರ್ಶಿಸಬಲ್ಲಂತೆ ಮಾಡುತ್ತವೆ.

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

Architecture Decision Record (ADR): ಆರ್ಕಿಟೆಕ್ಚರ್ ದೃಷ್ಟಿಯಿಂದ ಮಹತ್ವದ ನಿರ್ಧಾರವನ್ನು — ಅದರ ಸಂದರ್ಭ, ಆಯ್ಕೆ ಮಾಡಿದ ಆಯ್ಕೆ, ಪರಿಗಣಿಸಿದ ಪರ್ಯಾಯಗಳು ಮತ್ತು ಕೆಳಹಂತದ ಪರಿಣಾಮಗಳು — ಸೆರೆಹಿಡಿಯುವ ರಚನಾತ್ಮಕ, ಶಾಶ್ವತವಾಗಿ ಉಳಿಸಲಾದ ದಾಖಲೆ, ಇದರಿಂದ ಭವಿಷ್ಯದ ವಿಮರ್ಶಕರು ವ್ಯವಸ್ಥೆ ಹೀಗೆ ಏಕೆ ಕಾಣುತ್ತದೆ ಎಂಬುದನ್ನು ಆಡಿಟ್ ಮಾಡಬಹುದು.
Decision Taxonomy: ಪ್ರತಿಯೊಂದು ADR ಅನ್ನು ವರ್ಗೀಕರಿಸುವ ವರ್ಗಗಳ ನಿಯಂತ್ರಿತ ಶಬ್ದಕೋಶ (ಉದಾ. MODEL_SELECTION, HOSTING_STRATEGY, RAG_VS_FINE_TUNING). ಇದನ್ನು enum ಆಗಿ ಎನ್‌ಕೋಡ್ ಮಾಡುವುದರಿಂದ ಸ್ಕೀಮಾ ವರ್ಗ-ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯ ಕ್ಷೇತ್ರಗಳನ್ನು ಜಾರಿಗೊಳಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಮತ್ತು ಗವರ್ನೆನ್ಸ್ ಕ್ವೆರಿಗಳನ್ನು ಟೈಪ್-ಸುರಕ್ಷಿತವಾಗಿಸುತ್ತದೆ.
Telemetry Validator: ADR ರಚನೆಯ ಸಮಯದಲ್ಲಿ ಅದಕ್ಕೆ ಬಂಧಿಸಲಾದ ಹೆಸರಿಸಿದ ಪ್ರೊಡಕ್ಷನ್ ಪರಿಶೀಲನೆ (ಉದಾ. "p95_latency_under_500ms"). ಲೈವ್ ಮೆಟ್ರಿಕ್‌ಗಳ ವಿರುದ್ಧ ಪರಿಶೀಲನೆ ವಿಫಲವಾದಾಗ, ಗವರ್ನೆನ್ಸ್ ವ್ಯವಸ್ಥೆಯು ಮಾನವ ವಿಮರ್ಶೆಯ ಅಗತ್ಯವಿಲ್ಲದೆ ನಿರ್ಧಾರವನ್ನು ಹಳತಾದದ್ದು ಎಂದು ಫ್ಲ್ಯಾಗ್ ಮಾಡುತ್ತದೆ.

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

ಕೆಳಗಿನ ಎರಡು ವಿಚಾರಗಳು ಸ್ಕೀಮಾದ ಆಕಾರವನ್ನು ಸಮರ್ಥಿಸುತ್ತವೆ: ಮೊದಲನೆಯದಾಗಿ, GenAI ಆರ್ಕಿಟೆಕ್ಚರ್ ಕೆಲಸಕ್ಕೆ ಸಾಮಾನ್ಯ ADR ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡುವ ಬದಲು ತನ್ನದೇ ಆದ ವರ್ಗ ಟ್ಯಾಕ್ಸಾನಮಿ ಏಕೆ ಬೇಕು, ಮತ್ತು ಎರಡನೆಯದಾಗಿ, ಪ್ರೊಡಕ್ಷನ್‌ನಲ್ಲಿ ಆಡಿಟ್ ಮಾಡಬಲ್ಲಂತೆ ಉಳಿಯಲು ADRSchema ಎನ್‌ಕೋಡ್ ಮಾಡಬೇಕಾದ ವಿನ್ಯಾಸ ತತ್ವಗಳು — ಸ್ಪಷ್ಟ ಮಾನದಂಡ ತೂಕಗಳು, ಬಂಧಿಸಲಾದ ಟೆಲಿಮೆಟ್ರಿ ವ್ಯಾಲಿಡೇಟರ್‌ಗಳು, enum-ಟೈಪ್ಡ್ ಸ್ಥಿತಿ ಮತ್ತು ಅವಲಂಬನೆ ಅಂಚುಗಳು.

GenAI ನಿರ್ಧಾರಗಳಿಗೆ ಕಸ್ಟಮ್ ಟ್ಯಾಕ್ಸಾನಮಿ ಏಕೆ ಅಗತ್ಯ

ನಿರ್ಧಾರ ಟ್ಯಾಕ್ಸಾನಮಿ ಎಂದರೆ ಪ್ರತಿಯೊಂದು ಆರ್ಕಿಟೆಕ್ಚರ್ ನಿರ್ಧಾರವನ್ನು ಉತ್ತಮವಾಗಿ-ವ್ಯಾಖ್ಯಾನಿಸಿದ ವರ್ಗಕ್ಕೆ ವರ್ಗೀಕರಿಸುವ ನಿಯಂತ್ರಿತ ಶಬ್ದಕೋಶ. GenAI ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ, ಮೂರು ನಿರ್ಧಾರ ವರ್ಗಗಳು ದಿನನಿತ್ಯದ ಆರ್ಕಿಟೆಕ್ಚರ್ ಕೆಲಸದಲ್ಲಿ ಪ್ರಾಬಲ್ಯ ಹೊಂದಿವೆ, ಮತ್ತು ಪ್ರತಿಯೊಂದೂ ವಿಭಿನ್ನ ಮೌಲ್ಯಮಾಪನ ಮಾನದಂಡಗಳನ್ನು ಹೊಂದಿದೆ:

ಮಾಡೆಲ್ ಆಯ್ಕೆ: ನಿರ್ದಿಷ್ಟ ಸಾಮರ್ಥ್ಯಕ್ಕೆ ಯಾವ ಫೌಂಡೇಶನ್ ಮಾಡೆಲ್ ಸೇವೆ ಸಲ್ಲಿಸುತ್ತದೆ? ಈ ನಿರ್ಧಾರವು ಪ್ರತಿ-ಟೋಕನ್ ವೆಚ್ಚ, ಲೇಟೆನ್ಸಿ ಪರ್ಸೆಂಟೈಲ್‌ಗಳು, ಗುಣಮಟ್ಟ ಬೆಂಚ್‌ಮಾರ್ಕ್‌ಗಳು (MMLU, HumanEval, ಡೊಮೇನ್-ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಮಾಪನಗಳು), ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋ ಗಾತ್ರ, ಫೈನ್-ಟ್ಯೂನಿಂಗ್ ಬೆಂಬಲ ಮತ್ತು ವೆಂಡರ್ ಲಾಕ್-ಇನ್ ಅಪಾಯವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
ಹೋಸ್ಟಿಂಗ್ ತಂತ್ರ: ಇನ್ಫರೆನ್ಸ್ ಎಲ್ಲಿ ಚಲಿಸುತ್ತದೆ? ಆಯ್ಕೆಗಳು ಸಂಪೂರ್ಣ-ನಿರ್ವಹಿತ API‌ಗಳು (OpenAI, Anthropic, Google), ಕ್ಲೌಡ್-ಹೋಸ್ಟೆಡ್ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳು (SageMaker, Vertex AI, Azure ML), ಮತ್ತು ಸ್ವಯಂ-ಹೋಸ್ಟೆಡ್ ಮೂಲಸೌಕರ್ಯ (ಮೀಸಲಾದ GPU‌ಗಳ ಮೇಲೆ vLLM) ವರೆಗೆ ವ್ಯಾಪಿಸಿವೆ. ಪ್ರತಿಯೊಂದು ಆಯ್ಕೆಯೂ ವೆಚ್ಚ ನಿಯಂತ್ರಣವನ್ನು ಕಾರ್ಯಾಚರಣೆಯ ಹೊರೆಯ ವಿರುದ್ಧ ಟ್ರೇಡ್-ಆಫ್ ಮಾಡುತ್ತದೆ.
RAG vs. ಫೈನ್-ಟ್ಯೂನಿಂಗ್: ವ್ಯವಸ್ಥೆಯು ಡೊಮೇನ್ ಜ್ಞಾನವನ್ನು ಹೇಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ? Retrieval-Augmented Generation ಬೇಸ್ ಮಾಡೆಲ್ ಅನ್ನು ಫ್ರೋಜನ್ ಆಗಿ ಇಟ್ಟು ಕ್ವೆರಿ ಸಮಯದಲ್ಲಿ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ; ಫೈನ್-ಟ್ಯೂನಿಂಗ್ ಜ್ಞಾನವನ್ನು ಮಾಡೆಲ್ ವೇಟ್‌ಗಳಲ್ಲಿ ಬೇಕ್ ಮಾಡುತ್ತದೆ. ಹೈಬ್ರಿಡ್ ವಿಧಾನಗಳು ಎರಡನ್ನೂ ಸಂಯೋಜಿಸುತ್ತವೆ. ನಿರ್ಧಾರವು ಡೇಟಾ ತಾಜಾತನದ ಅಗತ್ಯತೆಗಳು, ತರಬೇತಿ ಮೂಲಸೌಕರ್ಯದ ಲಭ್ಯತೆ ಮತ್ತು ಸ್ವೀಕಾರಾರ್ಹ ಲೇಟೆನ್ಸಿ ಬಜೆಟ್‌ಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ.

ಈ ಮೂರು ಪ್ರಾಥಮಿಕ ವರ್ಗಗಳ ಜೊತೆಗೆ, ಪ್ರೊಡಕ್ಷನ್ ಟ್ಯಾಕ್ಸಾನಮಿಗೆ ಗಾರ್ಡ್‌ರೈಲ್ ತಂತ್ರ (ವಿಷಯ ಫಿಲ್ಟರಿಂಗ್ ವಿಧಾನ), ಎಂಬೆಡ್ಡಿಂಗ್ ಮಾಡೆಲ್ ಆಯ್ಕೆ (ವೆಕ್ಟರ್ ಪ್ರತಿನಿಧಿತ್ವ ಆಯ್ಕೆಗಳು), ಮತ್ತು ಆರ್ಕೆಸ್ಟ್ರೇಷನ್ ಪ್ಯಾಟರ್ನ್ (ಏಕ-ಕಾಲ್ vs. ಏಜೆಂಟ್ ಲೂಪ್ vs. ಚೈನ್-ಆಫ್-ಥಾಟ್ ಪೈಪ್‌ಲೈನ್) ವರ್ಗಗಳೂ ಬೇಕು. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ದಾಖಲೆಗಳನ್ನು ಮುರಿಯದೆ ಇವುಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಲು ಸ್ಕೀಮಾ ವಿಸ್ತರಿಸಬಲ್ಲದಾಗಿರಬೇಕು.

ಪ್ರೊಡಕ್ಷನ್ ADR ಸ್ಕೀಮಾಗಳಿಗೆ ವಿನ್ಯಾಸ ತತ್ವಗಳು

ಈ ಸ್ಕೀಮಾ ವಿನ್ಯಾಸದಿಂದ ಹಲವಾರು ತತ್ವಗಳು ಹೊರಹೊಮ್ಮುತ್ತವೆ, ಅವು GenAI ವರ್ಕ್‌ಲೋಡ್‌ಗಳನ್ನು ಗುರಿಯಾಗಿಸಿಕೊಂಡ ಯಾವುದೇ ADR ವ್ಯವಸ್ಥೆಗೆ ವ್ಯಾಪಕವಾಗಿ ಅನ್ವಯಿಸುತ್ತವೆ:

ವರ್ಗ-ನಿರ್ದಿಷ್ಟ ಅಸ್ಥಿರತೆಗಳನ್ನು (invariants) ಕ್ವೆರಿ ಸಮಯದ ಬದಲು ರಚನೆಯ ಸಮಯದಲ್ಲಿ ಜಾರಿಗೊಳಿಸಿ. ವ್ಯವಸ್ಥೆಯನ್ನು ಪ್ರವೇಶಿಸುವ ತಪ್ಪಾಗಿ ರೂಪುಗೊಂಡ ADR ಅವಲಂಬನೆ ಗ್ರಾಫ್‌ಗಳನ್ನು ಕಲುಷಿತಗೊಳಿಸುತ್ತದೆ, ಗವರ್ನೆನ್ಸ್ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗಳನ್ನು ವಕ್ರಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಸ್ವಚ್ಛಗೊಳಿಸುವಿಕೆಯನ್ನು ವಿರೋಧಿಸುತ್ತದೆ. validate ವಿಧಾನ ಮತ್ತು build_category_context ಫ್ಯಾಕ್ಟರಿ ಶಾಶ್ವತ ಉಳಿಸುವಿಕೆಗೆ ಮೊದಲೇ ಸಮಸ್ಯೆಗಳನ್ನು ಹಿಡಿಯುತ್ತವೆ.
ಮಾನದಂಡ ತೂಕಗಳನ್ನು ಸ್ಪಷ್ಟ ಮತ್ತು ಸಾಮಾನ್ಯೀಕರಿಸಿದಂತೆ ಮಾಡಿ. ತೂಕದ ಮಾನದಂಡ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ನೇರವಾಗಿ ADR ದಾಖಲೆಯಲ್ಲಿ ಎಂಬೆಡ್ ಮಾಡಿದಾಗ, ಯಾವುದೇ ವಿಮರ್ಶಕರು ವೆಚ್ಚ, ಲೇಟೆನ್ಸಿ ಮತ್ತು ಗುಣಮಟ್ಟವನ್ನು ಹೇಗೆ ಸಮತೋಲನಗೊಳಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ನೋಡಬಹುದು. ತೂಕಗಳ ಮೊತ್ತ 1.0 ಆಗಿರಬೇಕೆಂದು ಅಗತ್ಯಪಡಿಸುವುದು, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಮಾನದಂಡಗಳನ್ನು ಮರುಸಮತೋಲನಗೊಳಿಸದೆ ಹೊಸ ಮಾನದಂಡವನ್ನು ಸೇರಿಸುವ ಸಾಮಾನ್ಯ ತಪ್ಪನ್ನು ತಡೆಯುತ್ತದೆ.
ರಚನೆಯ ಸಮಯದಲ್ಲಿ ಟೆಲಿಮೆಟ್ರಿ ವ್ಯಾಲಿಡೇಟರ್‌ಗಳನ್ನು ನಿರ್ಧಾರಗಳಿಗೆ ಬಂಧಿಸಿ. telemetry_validators ಕ್ಷೇತ್ರವು ಈ ನಿರ್ಧಾರದ ಊಹೆಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ನಿರ್ದಿಷ್ಟ ಪ್ರೊಡಕ್ಷನ್ ಪರಿಶೀಲನೆಗಳನ್ನು (ಉದಾ., "p95_latency_under_500ms", "cost_per_request_under_0.02") ಹೆಸರಿಸುತ್ತದೆ. ವ್ಯಾಲಿಡೇಟರ್‌ಗಳನ್ನು ಮುಂಚಿತವಾಗಿ ಘೋಷಿಸಿದಾಗ, ಟೆಲಿಮೆಟ್ರಿ ವ್ಯಾಲಿಡೇಶನ್ ವ್ಯವಸ್ಥೆಯು ಮಾನವ ಹಸ್ತಕ್ಷೇಪವಿಲ್ಲದೆ ಹಳತಾದ ನಿರ್ಧಾರಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪತ್ತೆಹಚ್ಚಬಹುದು.
ಸ್ಥಿತಿ ಪರಿವರ್ತನೆಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಅಲ್ಲ, enum ಆಗಿ ಮಾಡೆಲ್ ಮಾಡಿ. ಮುಕ್ತ-ಪಠ್ಯ ಸ್ಥಿತಿ ಮೌಲ್ಯಗಳ ಬದಲು ADRStatus ಬಳಸುವುದು ಟೈಪೋಗಳನ್ನು ತಡೆಯುತ್ತದೆ, ಗವರ್ನೆನ್ಸ್ ಲಾಜಿಕ್‌ನಲ್ಲಿ ಸಮಗ್ರ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್ ಅನ್ನು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ ಮತ್ತು ಸ್ಥಿತಿ-ಆಧಾರಿತ ಕ್ವೆರಿಗಳನ್ನು ಟೈಪ್-ಸುರಕ್ಷಿತವಾಗಿಸುತ್ತದೆ. ಒಂದು ನಿರ್ಧಾರ ACCEPTED ಆಗಿರುತ್ತದೆ ಅಥವಾ ಇಲ್ಲ—"approved", "active", ಅಥವಾ "in_effect" ನಂತಹ ವ್ಯತ್ಯಾಸಗಳಿಂದ ಯಾವುದೇ ಅಸ್ಪಷ್ಟತೆ ಇರುವುದಿಲ್ಲ.
ಮೊದಲ ದಿನದಿಂದಲೇ ಅವಲಂಬನೆ ಟ್ರಾವರ್ಸಲ್‌ಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಿ. dependencies ಕ್ಷೇತ್ರವು ADR ID‌ಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಪಟ್ಟಿಯಾಗಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ, ನಿರ್ಧಾರ ಅವಲಂಬನೆ ಗ್ರಾಫ್‌ನಲ್ಲಿ ಅಂಚುಗಳನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಹೋಸ್ಟಿಂಗ್ ತಂತ್ರದ ನಿರ್ಧಾರವು ಹಳತಾದಾಗ (superseded), ಆ ಹೋಸ್ಟಿಂಗ್ ಪರಿಸರವನ್ನು ಊಹಿಸಿದ ಪ್ರತಿಯೊಂದು ಕೆಳಹಂತದ ಮಾಡೆಲ್ ಆಯ್ಕೆ ADR ಅನ್ನು ವಿಮರ್ಶೆಗೆ ಫ್ಲ್ಯಾಗ್ ಮಾಡಬೇಕು. ಸ್ಪಷ್ಟ ಅವಲಂಬನೆ ಟ್ರ್ಯಾಕಿಂಗ್ ಇಲ್ಲದೆ, ಈ ಸರಣಿ ಅಮಾನ್ಯೀಕರಣಗಳು ಪ್ರೊಡಕ್ಷನ್ ಘಟನೆಗಳು ಅವುಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸುವವರೆಗೆ ಗಮನಕ್ಕೆ ಬಾರದೆ ಹೋಗುತ್ತವೆ.

ಈ ವಿಭಾಗದಲ್ಲಿ ನೀವು ನಿರ್ಮಿಸಿದ ಸ್ಕೀಮಾ ನಂತರ ಬರುವ ಎಲ್ಲದಕ್ಕೂ ರಚನಾತ್ಮಕ ಬೆನ್ನೆಲುಬಾಗಿದೆ: ಇನ್ನೊಂದು ಗುರಿಯಲ್ಲಿನ ತೂಕದ ಸ್ಕೋರಿಂಗ್ ಎಂಜಿನ್, ಇನ್ನೊಂದು ಗುರಿಯಲ್ಲಿನ ಟೆಲಿಮೆಟ್ರಿ ವ್ಯಾಲಿಡೇಶನ್ ಪೈಪ್‌ಲೈನ್, ಇನ್ನೊಂದು ಗುರಿಯಲ್ಲಿನ ಅವಲಂಬನೆ ಗ್ರಾಫ್ ಟ್ರಾವರ್ಸಲ್, ಮತ್ತು ಇನ್ನೊಂದು ಗುರಿಯಲ್ಲಿನ ಗವರ್ನೆನ್ಸ್ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್. ಪ್ರತಿಯೊಂದು ಕೆಳಹಂತದ ವ್ಯವಸ್ಥೆಯೂ ADRSchema ಇನ್‌ಸ್ಟೆನ್ಸ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಡೇಟಾ ಗುಣಮಟ್ಟವನ್ನು ಖಾತರಿಪಡಿಸಲು validate ಮತ್ತು build_category_context ಜಾರಿಗೊಳಿಸುವ ಅಸ್ಥಿರತೆಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ.

Loading diagram...

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

ಮೇಲಿನ ನಿರ್ಧಾರ ಟ್ಯಾಕ್ಸಾನಮಿ ಮತ್ತು ವಿನ್ಯಾಸ ತತ್ವಗಳ ಮೇಲೆ ನಿರ್ಮಿಸಿ, ಕೆಳಗಿನ Python ಅವುಗಳನ್ನು ಕಾಂಕ್ರೀಟ್ ಟೈಪ್‌ಗಳಾಗಿ ಭಾಷಾಂತರಿಸುತ್ತದೆ: DecisionCategory ಮತ್ತು ADRStatus enum‌ಗಳು, ಮತ್ತು validate ಹಾಗೂ is_expired ವಿಧಾನಗಳೊಂದಿಗೆ ADRSchema dataclass. ಟೈಪ್ಡ್ ADR ವ್ಯವಸ್ಥೆಯ ಅಡಿಪಾಯವೆಂದರೆ ನಿಮ್ಮ ಸಂಸ್ಥೆ ಗುರುತಿಸುವ ಪ್ರತಿಯೊಂದು ನಿರ್ಧಾರ ವರ್ಗವನ್ನು ಸಮಗ್ರವಾಗಿ ಪಟ್ಟಿ ಮಾಡುವ enum, ಮತ್ತು ಅದರ ಜೊತೆ ಪ್ರತಿಯೊಂದು ADR ದಾಖಲೆಯ ಆಕಾರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ dataclass. ADRSchema ಪ್ರತಿಯೊಂದು ದಾಖಲೆಯೂ ಟ್ಯಾಕ್ಸಾನಮಿಯಿಂದ ಪಡೆದ ವರ್ಗ, ವರ್ಗ-ನಿರ್ದಿಷ್ಟ ಮೆಟಾಡೇಟಾಗಾಗಿ ರಚನಾತ್ಮಕ context ಡಿಕ್ಷನರಿ, ತೂಕದ ಮಾನದಂಡ ಮ್ಯಾಟ್ರಿಕ್ಸ್‌ಗಾಗಿ 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 ವರ್ಗಗಳನ್ನು ಮತ್ತು ಪ್ರೊಡಕ್ಷನ್ ತಂಡಗಳಿಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಬೇಕಾಗುವ ಮೂರು ವಿಸ್ತರಣೆ ವರ್ಗಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ, ಪ್ರತಿಯೊಂದೂ ಸೀರಿಯಲೈಸೇಶನ್‌ಗಾಗಿ snake_case ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ADRStatus PROPOSED ನಿಂದ ACCEPTED, SUPERSEDED, DEPRECATED, ಅಥವಾ REJECTED ವರೆಗಿನ ಸಂಪೂರ್ಣ ಜೀವನಚಕ್ರವನ್ನು ಮಾಡೆಲ್ ಮಾಡುತ್ತದೆ. ADRSchema dataclass ಒಂದು ದಾಖಲೆ ಹೊಂದಿರುವ ಪ್ರತಿಯೊಂದು ಕ್ಷೇತ್ರವನ್ನೂ ಘೋಷಿಸುತ್ತದೆ, ಇದರಲ್ಲಿ criteria_weights ನಿರ್ಧಾರ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಮತ್ತು ಡಿಪ್ಲಾಯ್‌ಮೆಂಟ್ ನಂತರ ಚಲಿಸುವ telemetry_validators ಸೇರಿವೆ. validate ವಿಧಾನವು ರಚನಾತ್ಮಕ ಅಸ್ಥಿರತೆಗಳನ್ನು ಜಾರಿಗೊಳಿಸುತ್ತದೆ — ಖಾಲಿಯಲ್ಲದ ಶೀರ್ಷಿಕೆ ಮತ್ತು ನಿರ್ಧಾರ, ಕನಿಷ್ಠ ಒಂದು ಪರಿಣಾಮ, ಮಾಡೆಲ್-ಆಯ್ಕೆ ADR‌ಗಳಿಗೆ ಅಗತ್ಯ ಕಾಂಟೆಕ್ಸ್ಟ್ ಕೀಗಳು, ಮತ್ತು ಸಹಿಷ್ಣುತೆಯೊಳಗೆ 1.0 ಕ್ಕೆ ಮೊತ್ತವಾಗುವ ಮಾನದಂಡ ತೂಕಗಳು — ಯಾವುದೇ ಉಲ್ಲಂಘನೆಯ ಮೇಲೆ ValueError ಎತ್ತುತ್ತದೆ. is_expired ವಿಧಾನವು review_by ಗಡುವು ಹೊಂದಿಸದಿದ್ದಾಗ False ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಇಲ್ಲದಿದ್ದರೆ ಪ್ರಸ್ತುತ UTC ಸಮಯವನ್ನು ಅದರ ವಿರುದ್ಧ ಹೋಲಿಸುತ್ತದೆ, ಇದರಿಂದ ಗವರ್ನೆನ್ಸ್ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗಳು ಹಳತಾದ ನಿರ್ಧಾರಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸಬಹುದು. context ಕೀಗಳು model_name, provider, ಮತ್ತು use_case ಹಾಗೂ 1.0 ಕ್ಕೆ ಮೊತ್ತವಾಗುವ criteria_weights ಹೊಂದಿರುವ MODEL_SELECTION ADR ಅನ್ನು ಇನ್‌ಸ್ಟೆನ್ಸ್ ಮಾಡಿ, ನಂತರ validate ಕರೆ ಮಾಡಿ ಪರಿಶೀಲಿಸಿ — ಅದು True ಹಿಂತಿರುಗಿಸಿದಾಗ ಅದು ಕೆಲಸ ಮಾಡುತ್ತಿದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿಯುತ್ತದೆ, ಆದರೆ ಆ ಕೀಗಳು ಇಲ್ಲದ ಅಥವಾ 0.01 ಕ್ಕಿಂತ ಹೆಚ್ಚು ವ್ಯತ್ಯಾಸವಿರುವ ತೂಕಗಳ ಇನ್‌ಸ್ಟೆನ್ಸ್ ValueError ಎತ್ತುತ್ತದೆ.

ಶಿಸ್ತು ಅನ್ವಯ

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

ಮಾಡಬೇಕಾದವು

validate() ಕರೆ ಮಾಡುವ ಮೊದಲು context ಅನ್ನು ಅಗತ್ಯ ವರ್ಗ-ನಿರ್ದಿಷ್ಟ ಕೀಗಳೊಂದಿಗೆ ತುಂಬಿಸಿ — MODEL_SELECTION ADR‌ಗಳಿಗೆ, validate() {"model_name", "provider", "use_case"} context.keys() ನ ಉಪಗಣವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಯಾವುದಾದರೂ ಕಾಣೆಯಾಗಿದ್ದರೆ ValueError ಎತ್ತುತ್ತದೆ; ಇಲ್ಲಿ ರಚನಾತ್ಮಕ ಮೆಟಾಡೇಟಾ ಒದಗಿಸುವುದೇ ಮಾಡೆಲ್ ನಿರ್ಧಾರಗಳನ್ನು ಮುಕ್ತ-ಪಠ್ಯ ಬ್ಲಾಬ್‌ಗಳ ಬದಲು ಕ್ವೆರಿ ಮಾಡಬಲ್ಲ ಮತ್ತು diff ಮಾಡಬಲ್ಲಂತೆ ಮಾಡುತ್ತದೆ.
criteria_weights ಮೌಲ್ಯಗಳು validate() ಜಾರಿಗೊಳಿಸುವ 0.01 ಸಹಿಷ್ಣುತೆಯೊಳಗೆ 1.0 ಕ್ಕೆ ಮೊತ್ತವಾಗುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ — ವಿಧಾನವು sum(criteria_weights.values()) ಅನ್ನು ಲೆಕ್ಕಹಾಕುತ್ತದೆ ಮತ್ತು [0.99, 1.01] ಹೊರಗಿನ ಯಾವುದೇ ಮೊತ್ತವನ್ನು ತಿರಸ್ಕರಿಸುತ್ತದೆ; ಮೌನವಾಗಿ ಜಾರುವ ತೂಕಗಳ dict (ಉದಾ., ಎರಡು ಮಾನದಂಡಗಳು ಪ್ರತಿಯೊಂದೂ 0.6) ದಾಖಲೆಯು ಎಂದಿಗೂ ACCEPTED ಸ್ಥಿತಿಗೆ ತಲುಪದಂತೆ ತಡೆಯುತ್ತದೆ ಮತ್ತು ನಿರ್ಧಾರದ ತಾರ್ಕಿಕತೆಯನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಉಳಿಸಲು ಒತ್ತಾಯಿಸುತ್ತದೆ.
review_by datetime ಹೊಂದಿಸಿ ಮತ್ತು telemetry_validators ಅನ್ನು ನಿಜವಾದ ಪ್ರೊಡಕ್ಷನ್ ಪರಿಶೀಲನೆಗಳಿಗೆ ಬಂಧಿಸಿ — review_by None ಆಗಿದ್ದಾಗ is_expired() ಯಾವಾಗಲೂ False ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಹೀಗಾಗಿ ಗವರ್ನೆನ್ಸ್ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗಳು ಹಳತಾದ ನಿರ್ಧಾರಗಳನ್ನು ಎಂದಿಗೂ ಬಹಿರಂಗಪಡಿಸಲಾರವು; ಎರಡೂ ಕ್ಷೇತ್ರಗಳನ್ನು ತುಂಬಿಸದಿದ್ದರೆ, ಸಾಕ್ಷ್ಯಗಳು ವಿರುದ್ಧವಾಗಿ ತಿರುಗಿದ MODEL_SELECTION ಅಥವಾ RAG_VS_FINE_TUNING ADR ಸುಪರ್‌ಸೆಷನ್ ಅನ್ನು ಪ್ರಚೋದಿಸುವ ಬದಲು ಅನಿರ್ದಿಷ್ಟವಾಗಿ ತನ್ನ ACCEPTED ಸ್ಥಿತಿಯನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ.

ಮಾಡಬಾರದವು

DecisionCategory ಅನ್ನು ವಿಸ್ತರಿಸುವ ಬದಲು ಹೊಸ ನಿರ್ಧಾರ ಪ್ರಕಾರವನ್ನು context ನಲ್ಲಿ ಮುಕ್ತ-ಪಠ್ಯ ನಮೂದಾಗಿ ವ್ಯಕ್ತಪಡಿಸಬೇಡಿ — DecisionCategory enum ಸದಸ್ಯವಲ್ಲದ ಪ್ರತಿಯೊಂದು ವರ್ಗವೂ (ಉದಾ., HOSTING_STRATEGY, EMBEDDING_MODEL) ಟೈಪ್ಡ್ ಟ್ಯಾಕ್ಸಾನಮಿಯ ಹೊರಗೆ ಕುಳಿತಿರುತ್ತದೆ, ಹೀಗಾಗಿ ಅದನ್ನು ವರ್ಗದಿಂದ ಫಿಲ್ಟರ್ ಮಾಡಲಾಗದು, dependencies ಮೂಲಕ ಅವಲಂಬಿಸಲಾಗದು, ಅಥವಾ ಪ್ರೋಗ್ರಾಮ್ಯಾಟಿಕ್ ಆಗಿ ಸುಪರ್‌ಸೀಡ್ ಮಾಡಲಾಗದು — ಸ್ಕೀಮಾ ನಿವಾರಿಸಲು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕ್ವೆರಿ ಮಾಡಲಾಗದ ಮುಕ್ತ-ಪಠ್ಯ ಬ್ಲಾಬ್‌ಗಳನ್ನೇ ನಿಖರವಾಗಿ ಮರುಸೃಷ್ಟಿಸುತ್ತದೆ.
ADR ನ ಫಲಿತಾಂಶವು ಮೇಲ್ಹಂತದ ನಿರ್ಧಾರದ ಮೇಲೆ ನಿರ್ಮಿಸಿದಾಗ dependencies: list[str] ಅನ್ನು ಖಾಲಿ ಬಿಡಬೇಡಿ — ಈ ಕ್ಷೇತ್ರವು ಕೆಳಹಂತದ ADR‌ಗಳನ್ನು ಅವು ಅವಲಂಬಿಸಿರುವ ದಾಖಲೆಗಳಿಗೆ ಲಿಂಕ್ ಮಾಡುವ adr_id ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಹೊಂದಿದೆ; ಇದನ್ನು ಬಿಟ್ಟುಬಿಡುವುದೆಂದರೆ ನಿರ್ದಿಷ್ಟ EMBEDDING_MODEL ಅಥವಾ HOSTING_STRATEGY ಆಯ್ಕೆಯ ಮೇಲೆ ನಿಂತಿರುವ RAG_VS_FINE_TUNING ADR ಗೆ ಯಂತ್ರ-ಓದಬಲ್ಲ ಲಿಂಕ್ ಇರುವುದಿಲ್ಲ, ಹೀಗಾಗಿ ಮೇಲ್ಹಂತದ ದಾಖಲೆಯನ್ನು ಸುಪರ್‌ಸೀಡ್ ಮಾಡಿದಾಗ ಅನಾಥ, ಅಮಾನ್ಯ ನಿರ್ಧಾರಗಳು ಮೌನವಾಗಿ ಸಕ್ರಿಯವಾಗಿ ಉಳಿಯುತ್ತವೆ.
validate() ನಲ್ಲಿ ValueError ತಪ್ಪಿಸಲು consequences ತುಂಬಿಸುವುದನ್ನು ಬಿಟ್ಟುಬಿಡಬೇಡಿ — self.consequences ಖಾಲಿಯಾಗಿದ್ದರೆ validate() ಸ್ಪಷ್ಟವಾಗಿ ಎತ್ತುತ್ತದೆ, ಮತ್ತು ಈ ಕ್ಷೇತ್ರವು telemetry_validators ಡಿಪ್ಲಾಯ್‌ಮೆಂಟ್ ನಂತರ ಪರಿಶೀಲಿಸುವ ಪಠ್ಯ ಒಪ್ಪಂದವಾಗಿದೆ; ಪರಿಣಾಮಗಳಿಲ್ಲದ 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 Google Use 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.

Define GenAI ADR Pydantic models with decision categoriesLab5 min
Implement decision option scoring with weighted criteria matrixLab5 min
Build ADR persistence layer with versioning and supersede chainsLab5 min
GenAI ADR EngineChapter overview23 min

More free lessons in GenAI Architecture & Design Patterns

Ch 1Build ADR schema and decision taxonomy for GenAI technology choicesYou are here
Ch 1Validate ADR decisions against production telemetry
Ch 1Implement ADR recommendation engine using historical outcomes
Ch 1Create ADR governance dashboard and compliance audit
Ch 4Build eval gate component with pluggable evaluator registry
Ch 4Measure eval gate effectiveness with precision-recall tracking
Ch 4Create eval architecture audit report with coverage analysis

All free lessons in GenAI Solutions Architecture →