Building Real-World AI Systems with RAG, Agents, and LLM Applications

1
WHILE not done:
2
  1. LLM receives: system prompt + conversation history + tool schemas
3
  2. LLM outputs: Thought (reasoning) + Action (tool call)  OR  Final Answer
4
  3. If action:       execute tool → append Observation → go to step 1
5
  4. If final answer: return to user

1
# LangGraph — stateful agent with review cycle
2
from langgraph.graph import StateGraph, END
3
from typing import TypedDict, Annotated
4
import operator
5

6
class AgentState(TypedDict):
7
    messages: Annotated[list, operator.add]
8
    next: str
9

10
def analyst_node(state: AgentState):
11
    response = llm.invoke(state['messages'])
12
    return {'messages': [response]}
13

14
def reviewer_node(state: AgentState):
15
    response = reviewer_llm.invoke(state['messages'])
16
    # Routing decision based on response content
17
    if 'APPROVED' in response.content:
18
        return {'next': 'END', 'messages': [response]}
19
    return {'next': 'analyst', 'messages': [response]}
20

21
workflow = StateGraph(AgentState)
22
workflow.add_node('analyst', analyst_node)
23
workflow.add_node('reviewer', reviewer_node)
24
workflow.set_entry_point('analyst')
25
workflow.add_edge('analyst', 'reviewer')
26
workflow.add_conditional_edges(
27
    'reviewer',
28
    lambda s: s['next'],
29
    {'analyst': 'analyst', 'END': END}
30
)
31
app = workflow.compile()

1
import shap
2

3
# ── TreeExplainer: fast, exact SHAP for tree-based models ──────────────────
4
explainer = shap.TreeExplainer(xgboost_model)
5
shap_values = explainer.shap_values(X_test)
6

7
# Single prediction — waterfall plot shows each feature's contribution
8
shap.waterfall_plot(explainer(X_test)[0])
9

10
# Global feature importance — beeswarm (shows direction of effect)
11
shap.summary_plot(shap_values, X_test)
12

13
# Global feature importance — bar chart (mean absolute SHAP values)
14
shap.summary_plot(shap_values, X_test, plot_type='bar')
15

16
# Feature interaction — how two features jointly affect prediction
17
shap.dependence_plot('income', shap_values, X_test, interaction_index='age')
18

19
# ── LIME: local linear approximations (model-agnostic) ──────────────────────
20
from lime.lime_text import LimeTextExplainer
21

22
explainer = LimeTextExplainer(class_names=['negative', 'positive'])
23
explanation = explainer.explain_instance(
24
    text,
25
    classifier.predict_proba,
26
    num_features=10
27
)
28
explanation.show_in_notebook()

1
import re
2

3
# ── Layer 1: Input validation (fast, cheap) ────────────────────────────────
4
def validate_input(user_input: str) -> tuple[bool, str]:
5
    injection_patterns = [
6
        r'ignore previous',
7
        r'forget instructions',
8
        r'act as',
9
        r'jailbreak',
10
    ]
11
    for pattern in injection_patterns:
12
        if re.search(pattern, user_input, re.IGNORECASE):
13
            return False, 'Potential prompt injection detected'
14
    if len(user_input) > 2000:
15
        return False, 'Input exceeds maximum length'
16
    return True, 'OK'
17

18
# ── Layer 2: LLM-based classifier (Llama Guard) ────────────────────────────
19
from transformers import pipeline
20

21
guard = pipeline('text-classification', model='meta-llama/LlamaGuard-7b')
22
result = guard(f'[INST] {user_message} [/INST] {model_response}')
23
# Returns 'safe' or 'unsafe' with category
24

25
# ── Layer 3: Output validation ─────────────────────────────────────────────
26
def validate_output(response: str, retrieved_context: str) -> float:
27
    """Return faithfulness score [0, 1] — does response stay within context?"""
28
    # Use an NLI model to check if response is entailed by context
29
    from transformers import pipeline as hf_pipeline
30
    nli = hf_pipeline('text-classification', model='cross-encoder/nli-deberta-v3-base')
31
    result = nli(f'{retrieved_context} [SEP] {response}')
32
    # 'entailment' score is your faithfulness proxy
33
    return next(r['score'] for r in result if r['label'] == 'ENTAILMENT')

1
from openai import AzureOpenAI
2
import os
3

4
client = AzureOpenAI(
5
    api_key=os.getenv('AZURE_OPENAI_KEY'),
6
    api_version='2024-02-01',
7
    azure_endpoint=os.getenv('AZURE_OPENAI_ENDPOINT')
8
)
9

10
response = client.chat.completions.create(
11
    model='gpt-4o',          # This is the deployment name in your Azure resource
12
    messages=[{'role': 'user', 'content': 'Explain RAG in one paragraph.'}],
13
    max_tokens=500,
14
    temperature=0
15
)
16

17
print(response.choices[0].message.content)

1
import boto3, json
2

3
client = boto3.client('bedrock-runtime', region_name='us-east-1')
4

5
response = client.invoke_model(
6
    modelId='anthropic.claude-3-5-sonnet-20241022-v2:0',
7
    body=json.dumps({
8
        'anthropic_version': 'bedrock-2023-05-31',
9
        'max_tokens': 500,
10
        'messages': [{'role': 'user', 'content': 'Explain RAG in one paragraph.'}]
11
    })
12
)
13

14
result = json.loads(response['body'].read())
15
print(result['content'][0]['text'])

1
-- BigQuery ML: run LLM inference directly in SQL
2
SELECT
3
    customer_id,
4
    review_text,
5
    ML.GENERATE_TEXT(
6
        MODEL `project.dataset.gemini_model`,
7
        STRUCT(review_text AS prompt),
8
        STRUCT(0 AS temperature, 100 AS max_output_tokens)
9
    ) AS sentiment_analysis
10
FROM `project.dataset.customer_reviews`
11
WHERE DATE(created_at) = CURRENT_DATE()

1
from ragas import evaluate
2
from ragas.metrics import (
3
    faithfulness,       # Is the answer grounded in retrieved context? (no hallucinations)
4
    answer_relevancy,  # Does the answer address the question?
5
    context_precision, # Are the retrieved chunks relevant to the question?
6
    context_recall,    # Does the retrieved context cover the ground-truth answer?
7
    answer_correctness # Does the answer match the ground truth?
8
)
9
from datasets import Dataset
10

11
data = {
12
    'question':     ['What is the return policy?', 'How do I cancel my subscription?'],
13
    'answer':       ['Returns accepted within 30 days', 'Email support to cancel anytime'],
14
    'contexts':     [['Our policy allows returns in 30 days...'], ['Cancellations via support email...']],
15
    'ground_truth': ['Products can be returned within 30 days', 'Cancel by emailing support']
16
}
17

18
dataset = Dataset.from_dict(data)
19
results = evaluate(
20
    dataset,
21
    metrics=[faithfulness, answer_relevancy, context_precision, context_recall]
22
)
23
print(results.to_pandas())

1
# ── BLEU — precision-based, used for machine translation ──────────────────
2
from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
3

4
reference = [['the', 'product', 'works', 'well', 'overall']]
5
candidate = ['the', 'product', 'performs', 'well', 'overall']
6
score = sentence_bleu(reference, candidate, smoothing_function=SmoothingFunction().method1)
7
# BLEU weakness: 'works' ≠ 'performs' by BLEU — no semantic awareness
8

9
# ── ROUGE — recall-based, used for summarisation ──────────────────────────
10
from rouge_score import rouge_scorer
11

12
scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
13
scores = scorer.score(
14
    'Machine learning is a type of artificial intelligence.',
15
    'ML is a subset of AI that learns from data.'
16
)
17
# rouge1: unigram overlap | rouge2: bigram | rougeL: longest common subsequence
18

19
# ── BERTScore — semantic similarity using BERT embeddings ─────────────────
20
from bert_score import score as bert_score
21

22
P, R, F1 = bert_score(
23
    ['The product works well overall'],
24
    ['The item performs great in general'],
25
    lang='en'
26
)
27
print(f'BERTScore F1: {F1.mean():.4f}')  # Captures semantic similarity BLEU misses
28

29
# ── LLM-as-Judge (G-Eval) — best correlation with human judgement ─────────
30
# Use GPT-4 to score outputs on coherence, relevance, fluency
31
# Most expensive but most aligned with human evaluation

1
User → API Gateway → Input Guardrails → Intent Classifier
2
                                              ↓
3
                     ┌────────────────────────────────────────┐
4
                     │  Simple query            Complex query  │
5
                     ↓                               ↓         │
6
               RAG Pipeline              Agent with tools      │
7
               (policy docs)          (ticket lookup, order    │
8
                                       status, escalation)     │
9
                     └──────────────────┬─────────────────────┘
10
                                        ↓
11
                              Output Guardrails → User