Logging and Debugging Guardrails Generated Responses

1
from nemoguardrails import LLMRails, RailsConfig
2
3
config = RailsConfig.from_path("path/to/config")
4
rails = LLMRails(config, verbose=True)

1
response = rails.generate(messages=[
2
    {"role": "user", "content": "Hello!"}
3
])
4
5
info = rails.explain()
6
info.print_llm_calls_summary()

1
response = rails.generate(
2
    messages=[{"role": "user", "content": "Hello!"}],
3
    options={
4
        "log": {
5
            "activated_rails": True,
6
            "llm_calls": True,
7
            "internal_events": True,
8
            "colang_history": True
9
        }
10
    }
11
)

1
response.log.print_summary()

1
# Access LLM calls
2
for call in response.log.llm_calls:
3
    print(f"Task: {call.task}")
4
    print(f"Duration: {call.duration}s")
5
    print(f"Prompt tokens: {call.prompt_tokens}")
6
    print(f"Completion tokens: {call.completion_tokens}")
7
    print(f"Total tokens: {call.total_tokens}")
8
9
# Access activated rails
10
for rail in response.log.activated_rails:
11
    print(f"Type: {rail.type}, Name: {rail.name}")
12
    print(f"Decisions: {rail.decisions}")
13
    print(f"Duration: {rail.duration}s")
14
15
# Access stats
16
stats = response.log.stats
17
print(f"Total duration: {stats.total_duration}s")
18
print(f"Input rails: {stats.input_rails_duration}s")
19
print(f"Dialog rails: {stats.dialog_rails_duration}s")
20
print(f"Output rails: {stats.output_rails_duration}s")

1
response = rails.generate(
2
    messages=[{"role": "user", "content": "Hello!"}],
3
    options={
4
        "output_vars": ["triggered_input_rail", "triggered_output_rail"]
5
    }
6
)
7
8
print(response.output_data)
9
# {'triggered_input_rail': None, 'triggered_output_rail': None}

1
response = rails.generate(
2
    messages=[{"role": "user", "content": "Hello!"}],
3
    options={
4
        "output_vars": True
5
    }
6
)
7
8
# Access all context data
9
print(response.output_data.keys())

1
response = rails.generate(
2
    messages=[{"role": "user", "content": "Tell me about the company."}],
3
    options={
4
        "output_vars": ["triggered_input_rail", "relevant_chunks"],
5
        "log": {
6
            "activated_rails": True,
7
            "llm_calls": True
8
        }
9
    }
10
)
11
12
# Check if any rail was triggered
13
if response.output_data.get("triggered_input_rail"):
14
    print(f"Input blocked by: {response.output_data['triggered_input_rail']}")
15
16
# Inspect what happened
17
response.log.print_summary()

1
response = rails.generate(
2
    messages=[{"role": "user", "content": "Your message"}],
3
    options={
4
        "output_vars": ["triggered_input_rail"],
5
        "log": {"activated_rails": True}
6
    }
7
)
8
9
if response.output_data.get("triggered_input_rail"):
10
    # Find the input rail that blocked
11
    for rail in response.log.activated_rails:
12
        if rail.type == "input" and rail.stop:
13
            print(f"Blocked by: {rail.name}")
14
            # Check the LLM decision
15
            for action in rail.executed_actions:
16
                for llm_call in action.llm_calls:
17
                    print(f"Prompt: {llm_call.prompt}")
18
                    print(f"Completion: {llm_call.completion}")

1
response = rails.generate(
2
    messages=[{"role": "user", "content": "Hello!"}],
3
    options={
4
        "log": {
5
            "internal_events": True,
6
            "colang_history": True
7
        }
8
    }
9
)
10
11
# View internal events
12
for event in response.log.internal_events:
13
    print(f"{event['type']}: {event}")
14
15
# View Colang history
16
print(response.log.colang_history)

1
response = rails.generate(
2
    messages=[{"role": "user", "content": "Hello!"}],
3
    options={"log": {"llm_calls": True}}
4
)
5
6
total_tokens = 0
7
total_duration = 0
8
9
for call in response.log.llm_calls:
10
    print(f"Task: {call.task}")
11
    print(f"  Duration: {call.duration:.2f}s")
12
    print(f"  Tokens: {call.total_tokens}")
13
    total_tokens += call.total_tokens
14
    total_duration += call.duration
15
16
print(f"\nTotal: {total_tokens} tokens in {total_duration:.2f}s")

1
from nemoguardrails import LLMRails, RailsConfig
2
3
# Enable verbose mode for console output
4
config = RailsConfig.from_path("path/to/config")
5
rails = LLMRails(config, verbose=True)
6
7
# Generate with full logging
8
response = rails.generate(
9
    messages=[{"role": "user", "content": "What is the company policy?"}],
10
    options={
11
        "output_vars": True,
12
        "log": {
13
            "activated_rails": True,
14
            "llm_calls": True,
15
            "internal_events": True,
16
            "colang_history": True
17
        }
18
    }
19
)
20
21
# Print summary
22
print("=== Generation Summary ===")
23
response.log.print_summary()
24
25
# Check for blocked content
26
print("\n=== Rail Triggers ===")
27
print(f"Input rail triggered: {response.output_data.get('triggered_input_rail')}")
28
print(f"Output rail triggered: {response.output_data.get('triggered_output_rail')}")
29
30
# Analyze LLM calls
31
print("\n=== LLM Calls ===")
32
for call in response.log.llm_calls:
33
    print(f"{call.task}: {call.total_tokens} tokens, {call.duration:.2f}s")
34
35
# View final response
36
print(f"\n=== Response ===")
37
print(response.response[0]["content"])