PwC: Walk-In (Selected Candidate)

                  [ User Query Input ]
                           │
                           ▼
               [ API Gateway & Auth ]
                           │
             ┌─────────────┴─────────────┐
             ▼                           ▼
  [ Semantic Redis Cache ]     [ Query Pre-Processing ]
      (Cached Answer)          (Embedding & HyDE)
                                         │
                                         ▼
                           [ Scoped Vector Database ]
                             (ANN Similarity Search)
                                         │
                                         ▼
                           [ Cross-Encoder Reranker ]
                             (Top-K Document Chunks)
                                         │
                                         ▼
                           [ LLM Prompt Synthesis ]
                             (System Guardrails)
                                         │
                                         ▼
                           [ Groundedness Evaluator ]
                             (Fallbacks / SSE Stream)

1. Ingestion & Indexing: Raw documents are extracted, chunked (e.g., 500–1,000 tokens), embedded into dense vectors, and stored in a vector database alongside access-control metadata.
2. Query Pipeline & Pre-Processing: User query is authenticated via an API Gateway. Check a Semantic Cache (Redis) for existing answers. If missed, generate a query embedding (or apply Hypothetical Document Embeddings - HyDE).
3. Retrieval & Reranking: Perform Approximate Nearest Neighbor (ANN) vector search against the vector database using metadata filters. Run candidate chunks through a Cross-Encoder Reranker to select the top-\(K\) most relevant passages.
4. LLM Synthesis & Guardrails: Pass context chunks and user query inside a grounded system prompt to the LLM. Run an automated groundedness evaluation step before streaming the response via Server-Sent Events (SSE).

• Standard Linear Pipeline: Rigid execution sequence (Input -> Search -> Prompt -> Output) with zero dynamic adjustment or decision-making.
• Agentic AI Workflow: An autonomous loop driven by an LLM acting as a reasoning engine:
• Planning / ReAct Loop: Model breaks down a complex query into explicit sub-tasks (Thought -> Action -> Observation).
• Tool Routing: Dynamically calls tools (e.g., SQL execution, Web Search, Calculator API) using structured JSON schemas based on user context.
• Reflection & Fallback: Evaluates tool execution outputs. If output is invalid or incomplete, it self-corrects and iterates up to a maximum step limit before delivering the final response.

• Gen AI solutions do not exist in isolation. Pre-retrieval query routing, content moderation, document categorization, and vector reranking often rely on classical supervised ML models (classifiers) rather than heavy LLM calls to keep latency and costs low.
• Key Definitions:
• Loss Function vs. Cost Function: Loss function measures prediction error for a single data instance (e.g., Binary Cross-Entropy, MSE). Cost function is the average loss across the entire dataset.
• Classification vs. Regression: Classification predicts discrete class labels (e.g., routing a user query to "Legal" vs "HR"); Regression predicts continuous numerical outputs.

1. Detection Techniques: * Z-Score Method: Identifies data points lying beyond 3 standard deviations (\(\lvert Z \rvert > 3\)) from the mean for normally distributed data. * IQR (Interquartile Range): Defines outliers as points falling below \(Q_1 - 1.5 \times \text{IQR}\) or above \(Q_3 + 1.5 \times \text{IQR}\) (robust for non-normal distributions). * Isolation Forests: Unsupervised tree algorithm ideal for high-dimensional anomaly detection.

2. Treatment Methods: * Trimming/Removal: Dropping verified corrupt or erroneous records. * Winsorization (Capping): Capping extreme values at set percentiles (e.g., 1st and 99th percentiles) to retain data volume without skewing feature scales.

import pandas as pd

# Sample Data Setup
data = {
    'Student': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Marks': [85, 22, 45, 12, 67]
}
df = pd.DataFrame(data)

# Vectorized pandas operation to assign 'Pass'/'Fail' based on threshold < 30
df['Result'] = 'Pass'
df.loc[df['Marks'] < 30, 'Result'] = 'Fail'

print(df)

Output:

   Student  Marks Result
0    Alice     85   Pass
1      Bob     22   Fail
2  Charlie     45   Pass
3    David     12   Fail
4      Eve     67   Pass