feat: enhance ML Model Monitoring system design answer with detailed architecture, scale requirements, and Python implementation.

Author: singhsidhukuldeep

docs/Interview-Questions/AB-testing.md

@@ -1334,73 +1334,88 @@ This document provides a curated list of A/B Testing and Experimentation intervi
 ## Code Examples
 
 ### 1. Power Analysis and Sample Size (Python)
-Calculating the required sample size before starting an experiment.
 
-```python
-from statsmodels.stats.power import TTestIndPower
-import numpy as np
+??? success "View Code Example"
 
-# Parameters
-effect_size = 0.1  # Cohen's d (Standardized difference)
-alpha = 0.05       # Significance level (5%)
-power = 0.8        # Power (80%)
 
-analysis = TTestIndPower()
-sample_size = analysis.solve_power(effect_size=effect_size, power=power, alpha=alpha)
+    **Difficulty:** 🟢 Easy | **Tags:** `Code Example` | **Asked by:** Code Pattern
+    Calculating the required sample size before starting an experiment.
 
-print(f"Required sample size per group: {int(np.ceil(sample_size))}")
-```
+    ```python
+    from statsmodels.stats.power import TTestIndPower
+    import numpy as np
+
+    # Parameters
+    effect_size = 0.1  # Cohen's d (Standardized difference)
+    alpha = 0.05       # Significance level (5%)
+    power = 0.8        # Power (80%)
+
+    analysis = TTestIndPower()
+    sample_size = analysis.solve_power(effect_size=effect_size, power=power, alpha=alpha)
+
+    print(f"Required sample size per group: {int(np.ceil(sample_size))}")
+    ```
 
 ### 2. Bayesian A/B Test (Beta-Binomial)
-Updating beliefs about conversion rates.
 
-```python
-from scipy.stats import beta
+??? success "View Code Example"
 
-# Prior: Uniform distribution (Beta(1,1))
-alpha_prior = 1
-beta_prior = 1
 
-# Data: Group A
-conversions_A = 120
-failures_A = 880
+    **Difficulty:** 🟢 Easy | **Tags:** `Code Example` | **Asked by:** Code Pattern
+    Updating beliefs about conversion rates.
 
-# Data: Group B
-conversions_B = 140
-failures_B = 860
+    ```python
+    from scipy.stats import beta
+
+    # Prior: Uniform distribution (Beta(1,1))
+    alpha_prior = 1
+    beta_prior = 1
+
+    # Data: Group A
+    conversions_A = 120
+    failures_A = 880
 
-# Posterior
-posterior_A = beta(alpha_prior + conversions_A, beta_prior + failures_A)
-posterior_B = beta(alpha_prior + conversions_B, beta_prior + failures_B)
+    # Data: Group B
+    conversions_B = 140
+    failures_B = 860
 
-# Probability B > A (Approximate via simulation)
-samples = 100000
-prob_b_better = (posterior_B.rvs(samples) > posterior_A.rvs(samples)).mean()
+    # Posterior
+    posterior_A = beta(alpha_prior + conversions_A, beta_prior + failures_A)
+    posterior_B = beta(alpha_prior + conversions_B, beta_prior + failures_B)
 
-print(f"Probability B is better than A: {prob_b_better:.4f}")
-```
+    # Probability B > A (Approximate via simulation)
+    samples = 100000
+    prob_b_better = (posterior_B.rvs(samples) > posterior_A.rvs(samples)).mean()
+
+    print(f"Probability B is better than A: {prob_b_better:.4f}")
+    ```
 
 ### 3. Bootstrap Confidence Interval
-Calculating CI for non-normal metrics (e.g., Revenue per User).
-
-```python
-import numpy as np
-
-data_control = np.random.lognormal(mean=2, sigma=1, size=1000)
-data_variant = np.random.lognormal(mean=2.1, sigma=1, size=1000)
-
-def bootstrap_mean_diff(data1, data2, n_bootstrap=1000):
-    diffs = []
-    for _ in range(n_bootstrap):
-        # Sample with replacement
-        sample1 = np.random.choice(data1, len(data1), replace=True)
-        sample2 = np.random.choice(data2, len(data2), replace=True)
-        diffs.append(sample2.mean() - sample1.mean())
-    return np.percentile(diffs, [2.5, 97.5])
-
-ci = bootstrap_mean_diff(data_control, data_variant)
-print(f"95% CI for difference: {ci}")
-```
+
+??? success "View Code Example"
+
+
+    **Difficulty:** 🟢 Easy | **Tags:** `Code Example` | **Asked by:** Code Pattern
+    Calculating CI for non-normal metrics (e.g., Revenue per User).
+
+    ```python
+    import numpy as np
+
+    data_control = np.random.lognormal(mean=2, sigma=1, size=1000)
+    data_variant = np.random.lognormal(mean=2.1, sigma=1, size=1000)
+
+    def bootstrap_mean_diff(data1, data2, n_bootstrap=1000):
+        diffs = []
+        for _ in range(n_bootstrap):
+            # Sample with replacement
+            sample1 = np.random.choice(data1, len(data1), replace=True)
+            sample2 = np.random.choice(data2, len(data2), replace=True)
+            diffs.append(sample2.mean() - sample1.mean())
+        return np.percentile(diffs, [2.5, 97.5])
+
+    ci = bootstrap_mean_diff(data_control, data_variant)
+    print(f"95% CI for difference: {ci}")
+    ```
 
 ---
 

docs/Interview-Questions/LangChain.md

@@ -1473,79 +1473,94 @@ This is updated frequently but right now this is the most exhaustive list of typ
 ## Code Examples
 
 ### 1. Basic RAG Pipeline with LCEL
-```python
-from langchain_community.vectorstores import FAISS
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.runnables import RunnablePassthrough
-from langchain_openai import ChatOpenAI, OpenAIEmbeddings
-
-vectorstore = FAISS.from_texts(["harrison worked at kensho"], embedding=OpenAIEmbeddings())
-retriever = vectorstore.as_retriever()
-template = """Answer the question based only on the following context:
-{context}
-
-Question: {question}
-"""
-prompt = ChatPromptTemplate.from_template(template)
-model = ChatOpenAI()
-
-retrieval_chain = (
-    {"context": retriever, "question": RunnablePassthrough()}
-    | prompt
-    | model
-    | StrOutputParser()
-)
-
-retrieval_chain.invoke("where did harrison work?")
-```
+
+??? success "View Code Example"
+
+
+    **Difficulty:** 🟢 Easy | **Tags:** `Code Example` | **Asked by:** Code Pattern
+    ```python
+    from langchain_community.vectorstores import FAISS
+    from langchain_core.output_parsers import StrOutputParser
+    from langchain_core.prompts import ChatPromptTemplate
+    from langchain_core.runnables import RunnablePassthrough
+    from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+
+    vectorstore = FAISS.from_texts(["harrison worked at kensho"], embedding=OpenAIEmbeddings())
+    retriever = vectorstore.as_retriever()
+    template = """Answer the question based only on the following context:
+    {context}
+
+    Question: {question}
+    """
+    prompt = ChatPromptTemplate.from_template(template)
+    model = ChatOpenAI()
+
+    retrieval_chain = (
+        {"context": retriever, "question": RunnablePassthrough()}
+        | prompt
+        | model
+        | StrOutputParser()
+    )
+
+    retrieval_chain.invoke("where did harrison work?")
+    ```
 
 ### 2. Custom Agent with Tool Use
-```python
-from langchain.agents import tool
-from langchain_openai import ChatOpenAI
-from langchain.agents import AgentExecutor, create_tool_calling_agent
-from langchain_core.prompts import ChatPromptTemplate
 
-@tool
-def multiply(first_int: int, second_int: int) -> int:
-    """Multiply two integers together."""
-    return first_int * second_int
+??? success "View Code Example"
+
 
-tools = [multiply]
-llm = ChatOpenAI(model="gpt-3.5-turbo-0125")
+    **Difficulty:** 🟢 Easy | **Tags:** `Code Example` | **Asked by:** Code Pattern
+    ```python
+    from langchain.agents import tool
+    from langchain_openai import ChatOpenAI
+    from langchain.agents import AgentExecutor, create_tool_calling_agent
+    from langchain_core.prompts import ChatPromptTemplate
 
-prompt = ChatPromptTemplate.from_messages([
-    ("system", "You are a helpful assistant"),
-    ("user", "{input}"),
-    ("placeholder", "{agent_scratchpad}"),
-])
+    @tool
+    def multiply(first_int: int, second_int: int) -> int:
+        """Multiply two integers together."""
+        return first_int * second_int
 
-agent = create_tool_calling_agent(llm, tools, prompt)
-agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+    tools = [multiply]
+    llm = ChatOpenAI(model="gpt-3.5-turbo-0125")
 
-agent_executor.invoke({"input": "what is 5 times 8?"})
-```
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "You are a helpful assistant"),
+        ("user", "{input}"),
+        ("placeholder", "{agent_scratchpad}"),
+    ])
+
+    agent = create_tool_calling_agent(llm, tools, prompt)
+    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+    agent_executor.invoke({"input": "what is 5 times 8?"})
+    ```
 
 ### 3. Structured Output Extraction
-```python
-from typing import List
-from langchain_core.pydantic_v1 import BaseModel, Field
-from langchain_openai import ChatOpenAI
 
-class Person(BaseModel):
-    name: str = Field(description="The name of the person")
-    age: int = Field(description="The age of the person")
+??? success "View Code Example"
 
-class People(BaseModel):
-    people: List[Person]
 
-llm = ChatOpenAI()
-structured_llm = llm.with_structured_output(People)
+    **Difficulty:** 🟢 Easy | **Tags:** `Code Example` | **Asked by:** Code Pattern
+    ```python
+    from typing import List
+    from langchain_core.pydantic_v1 import BaseModel, Field
+    from langchain_openai import ChatOpenAI
+
+    class Person(BaseModel):
+        name: str = Field(description="The name of the person")
+        age: int = Field(description="The age of the person")
 
-text = "Alice is 30 years old and Bob is 25."
-structured_llm.invoke(text)
-```
+    class People(BaseModel):
+        people: List[Person]
+
+    llm = ChatOpenAI()
+    structured_llm = llm.with_structured_output(People)
+
+    text = "Alice is 30 years old and Bob is 25."
+    structured_llm.invoke(text)
+    ```
 
 ---