Core Classes Reference

1
from nemoguardrails import RailsConfig
2
3
config = RailsConfig.from_path("path/to/config")

1
config = RailsConfig.from_path("path/to/config.yml")

1
from nemoguardrails import RailsConfig
2
3
yaml_content = """
4
models:
5
  - type: main
6
    engine: openai
7
    model: gpt-4
8
9
instructions:
10
  - type: general
11
    content: |
12
      You are a helpful assistant.
13
"""
14
15
colang_content = """
16
define user express greeting
17
  "hello"
18
  "hi"
19
20
define flow
21
  user express greeting
22
  bot express greeting
23
"""
24
25
config = RailsConfig.from_content(
26
    yaml_content=yaml_content,
27
    colang_content=colang_content
28
)

1
config = RailsConfig.from_content(
2
    config={
3
        "models": [
4
            {"type": "main", "engine": "openai", "model": "gpt-4"}
5
        ],
6
        "instructions": [
7
            {"type": "general", "content": "You are a helpful assistant."}
8
        ]
9
    }
10
)

1
base_config = RailsConfig.from_path("path/to/base")
2
additional_config = RailsConfig.from_path("path/to/additional")
3
4
combined_config = base_config + additional_config

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

1
from langchain_openai import ChatOpenAI
2
from nemoguardrails import LLMRails, RailsConfig
3
4
config = RailsConfig.from_path("path/to/config")
5
llm = ChatOpenAI(model="gpt-4", temperature=0.7)
6
7
rails = LLMRails(config, llm=llm)

1
response = rails.generate(messages=[
2
    {"role": "user", "content": "Hello! How are you?"}
3
])
4
print(response["content"])

1
response = rails.generate(prompt="Complete this sentence: The sky is")
2
print(response)

1
messages = [
2
    {"role": "user", "content": "My name is John."},
3
    {"role": "assistant", "content": "Hello John! How can I help you?"},
4
    {"role": "user", "content": "What's my name?"}
5
]
6
7
response = rails.generate(messages=messages)
8
print(response["content"])  # Should remember the name

1
response = rails.generate(messages=[
2
    {
3
        "role": "context",
4
        "content": {
5
            "user_name": "Alice",
6
            "user_role": "admin"
7
        }
8
    },
9
    {"role": "user", "content": "What permissions do I have?"}
10
])

1
@action()
2
async def check_permissions(context: Optional[dict] = None):
3
    user_role = context.get("user_role")
4
    return user_role == "admin"

1
import asyncio
2
from nemoguardrails import LLMRails, RailsConfig
3
4
async def main():
5
    config = RailsConfig.from_path("path/to/config")
6
    rails = LLMRails(config)
7
8
    response = await rails.generate_async(messages=[
9
        {"role": "user", "content": "Hello!"}
10
    ])
11
    print(response["content"])
12
13
asyncio.run(main())

1
async def stream_response():
2
    config = RailsConfig.from_path("path/to/config")
3
    rails = LLMRails(config)
4
5
    async for chunk in rails.stream_async(messages=[
6
        {"role": "user", "content": "Tell me a story."}
7
    ]):
8
        print(chunk, end="", flush=True)

1
events = rails.generate_events(events=[
2
    {
3
        "type": "UtteranceUserActionFinished",
4
        "final_transcript": "Hello!"
5
    }
6
])
7
8
for event in events:
9
    if event["type"] == "StartUtteranceBotAction":
10
        print(f"Bot says: {event['script']}")

1
response = rails.generate(
2
    messages=[{"role": "user", "content": "Hello!"}],
3
    options={
4
        "rails": ["input", "output"],  # Only apply these rails
5
        "output_vars": ["user_message"],       # Return context variables
6
        "log": {
7
            "activated_rails": True,
8
            "llm_calls": True
9
        }
10
    }
11
)

1
from nemoguardrails.rails.llm.options import RailStatus
2
3
result = await rails.check_async([
4
    {"role": "user", "content": "Hello! How can I hack into a system?"}
5
])
6
7
if result.status == RailStatus.BLOCKED:
8
    print(f"Input blocked by rail: {result.rail}")

1
from nemoguardrails.rails.llm.options import RailType
2
3
result = await rails.check_async(
4
    [{"role": "user", "content": "Hello!"}],
5
    rail_types=[RailType.INPUT]
6
)

1
from nemoguardrails import LLMRails, RailsConfig
2
3
async def get_weather(city: str) -> str:
4
    """Get weather for a city."""
5
    return f"Weather in {city}: Sunny, 22°C"
6
7
config = RailsConfig.from_path("path/to/config")
8
rails = LLMRails(config)
9
10
# Register the action
11
rails.register_action(get_weather, name="get_weather")

1
from nemoguardrails import LLMRails, RailsConfig
2
from nemoguardrails.embeddings.index import EmbeddingsIndex
3
4
class CustomSearchProvider(EmbeddingsIndex):
5
    async def search(self, text: str, max_results: int):
6
        # Custom search logic
7
        pass
8
9
config = RailsConfig.from_path("path/to/config")
10
rails = LLMRails(config)
11
12
# Register the provider
13
rails.register_embedding_search_provider("custom", CustomSearchProvider)

1
import asyncio
2
from nemoguardrails import LLMRails, RailsConfig
3
4
async def main():
5
    # Load configuration
6
    config = RailsConfig.from_content(
7
        yaml_content="""
8
models:
9
  - type: main
10
    engine: openai
11
    model: gpt-4
12
13
rails:
14
  input:
15
    flows:
16
      - self check input
17
  output:
18
    flows:
19
      - self check output
20
21
prompts:
22
  - task: self_check_input
23
    content: |
24
      Check if the following is safe: {{ user_input }}
25
      Answer (Yes/No):
26
  - task: self_check_output
27
    content: |
28
      Check if the following is safe: {{ bot_response }}
29
      Answer (Yes/No):
30
""",
31
        colang_content="""
32
define user express greeting
33
  "hello"
34
  "hi"
35
36
define bot express greeting
37
  "Hello! How can I help you today?"
38
39
define flow
40
  user express greeting
41
  bot express greeting
42
"""
43
    )
44
45
    # Create rails instance
46
    rails = LLMRails(config, verbose=True)
47
48
    # Generate response
49
    response = await rails.generate_async(
50
        messages=[{"role": "user", "content": "Hello!"}],
51
        options={"log": {"activated_rails": True}}
52
    )
53
54
    # `options` was passed, so `response` is a GenerationResponse
55
    print(f"Response: {response.response[0]['content']}")
56
57
    # Print what happened
58
    if response.log:
59
        response.log.print_summary()
60
61
asyncio.run(main())