Agentic AI 102: Guardrails and Agent Analysis

Constructing A Profitable Relationship With Stakeholders

Find out how to Spin Up a Venture Construction with Cookiecutter

Within the first put up of this sequence (Agentic AI 101: Beginning Your Journey Constructing AI Brokers), we talked in regards to the fundamentals of making AI Brokers and launched ideas like reasoning, reminiscence, and instruments.

In fact, that first put up touched solely the floor of this new space of the info business. There may be a lot extra that may be achieved, and we’re going to be taught extra alongside the best way on this sequence.

So, it’s time to take one step additional.

On this put up, we’ll cowl three subjects:

Guardrails: these are protected blocks that stop a Massive Language Mannequin (LLM) from responding about some subjects.

Agent Analysis: Have you ever ever thought of how correct the responses from LLM are? I guess you probably did. So we’ll see the principle methods to measure that.

Monitoring: We can even be taught in regards to the built-in monitoring app in Agno’s framework.

We will start now.

Guardrails

Our first matter is the only, in my view. Guardrails are guidelines that can maintain an AI agent from responding to a given matter or listing of subjects.

I consider there’s a good likelihood that you’ve ever requested one thing to ChatGPT or Gemini and obtained a response like “I can’t speak about this matter”, or “Please seek the advice of an expert specialist”, one thing like that. Normally, that happens with delicate subjects like well being recommendation, psychological circumstances, or monetary recommendation.

These blocks are safeguards to forestall folks from hurting themselves, harming their well being, or their pockets. As we all know, LLMs are skilled on large quantities of textual content, ergo inheriting lots of dangerous content material with it, which might simply result in dangerous recommendation in these areas for folks. And I didn’t even point out hallucinations!

Take into consideration what number of tales there are of people that misplaced cash by following funding ideas from on-line boards. Or how many individuals took the improper drugs as a result of they examine it on the web.

Nicely, I assume you bought the purpose. We should stop our brokers from speaking about sure subjects or taking sure actions. For that, we’ll use guardrails.

One of the best framework I discovered to impose these blocks is Guardrails AI [1]. There, you will notice a hub filled with predefined guidelines {that a} response should observe in an effort to go and be exhibited to the person.

To get began shortly, first go to this hyperlink [2] and get an API key. Then, set up the package deal. Subsequent, kind the guardrails setup command. It can ask you a few questions which you could reply n (for No), and it’ll ask you to enter the API Key generated.

pip set up guardrails-ai
guardrails configure

As soon as that’s accomplished, go to the Guardrails AI Hub [3] and select one that you simply want. Each guardrail has directions on the way to implement it. Principally, you put in it through the command line after which use it like a module in Python.

For this instance, we’re selecting one referred to as Limit to Subject [4], which, as its title says, lets the person discuss solely about what’s within the listing. So, return to the terminal and set up it utilizing the code beneath.

guardrails hub set up hub://tryolabs/restricttotopic

Subsequent, let’s open our Python script and import some modules.

# Imports
from agno.agent import Agent
from agno.fashions.google import Gemini
import os

# Import Guard and Validator
from guardrails import Guard
from guardrails.hub import RestrictToTopic

Subsequent, we create the guard. We are going to limit our agent to speak solely about sports activities or the climate. And we’re limiting it to speak about shares.

# Setup Guard
guard = Guard().use(
    RestrictToTopic(
        valid_topics=["sports", "weather"],
        invalid_topics=["stocks"],
        disable_classifier=True,
        disable_llm=False,
        on_fail="filter"
    )
)

Now we are able to run the agent and the guard.

# Create agent
agent = Agent(
    mannequin= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
    description= "An assistant agent",
    directions= ["Be sucint. Reply in maximum two sentences"],
    markdown= True
    )

# Run the agent
response = agent.run("What is the ticker image for Apple?").content material

# Run agent with validation
validation_step = guard.validate(response)

# Print validated response
if validation_step.validation_passed:
    print(response)
else:
    print("Validation Failed", validation_step.validation_summaries[0].failure_reason)

That is the response once we ask a couple of inventory image.

Validation Failed Invalid subjects discovered: ['stocks']

If I ask a couple of matter that isn’t on the valid_topics listing, I can even see a block.

"What is the primary soda drink?"
Validation Failed No legitimate matter was discovered.

Lastly, let’s ask about sports activities.

"Who's Michael Jordan?"
Michael Jordan is a former skilled basketball participant extensively thought-about certainly one of 
the best of all time.  He gained six NBA championships with the Chicago Bulls.

And we noticed a response this time, as it’s a legitimate matter.

Let’s transfer on to the analysis of brokers now.

Agent Analysis

Since I began finding out LLMs and Agentic Ai, certainly one of my predominant questions has been about mannequin analysis. In contrast to conventional Knowledge Science Modeling, the place you’ve structured metrics which are enough for every case, for AI Brokers, that is extra blurry.

Thankfully, the developer group is fairly fast to find options for nearly every thing, and they also created this good package deal for LLMs analysis: deepeval.

DeepEval [5] is a library created by Assured AI that gathers many strategies to judge LLMs and AI Brokers. On this part, let’s be taught a few the principle strategies, simply so we are able to construct some instinct on the topic, and likewise as a result of the library is sort of intensive.

The primary analysis is essentially the most primary we are able to use, and it’s referred to as G-Eval. As AI instruments like ChatGPT grow to be extra frequent in on a regular basis duties, now we have to ensure they’re giving useful and correct responses. That’s the place G-Eval from the DeepEval Python package deal is available in.

G-Eval is sort of a sensible reviewer that makes use of one other AI mannequin to judge how nicely a chatbot or AI assistant is performing. For instance. My agent runs Gemini, and I’m utilizing OpenAI to evaluate it. This technique takes a extra superior strategy than a human one by asking an AI to “grade” one other AI’s solutions primarily based on issues like relevance, correctness, and readability.

It’s a pleasant option to check and enhance generative AI programs in a extra scalable means. Let’s shortly code an instance. We are going to import the modules, create a immediate, a easy chat agent, and ask it a couple of description of the climate for the month of Might in NYC.

# Imports
from agno.agent import Agent
from agno.fashions.google import Gemini
import os
# Analysis Modules
from deepeval.test_case import LLMTestCase, LLMTestCaseParams
from deepeval.metrics import GEval

# Immediate
immediate = "Describe the climate in NYC for Might"

# Create agent
agent = Agent(
    mannequin= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
    description= "An assistant agent",
    directions= ["Be sucint"],
    markdown= True,
    monitoring= True
    )

# Run agent
response = agent.run(immediate)

# Print response
print(response.content material)

It responds: “Gentle, with common highs within the 60s°F and lows within the 50s°F. Anticipate some rain“.

Good. Appears fairly good to me.

However how can we put a quantity on it and present a possible supervisor or consumer how our agent is doing?

Right here is how:

Create a check case passing the immediate and the response to the LLMTestCase class.
Create a metric. We are going to use the tactic GEval and add a immediate for the mannequin to check it for coherence, after which I give it the which means of what coherence is to me.
Give the output as evaluation_params.
Run the measure technique and get the rating and motive from it.

# Check Case
test_case = LLMTestCase(enter=immediate, actual_output=response)

# Setup the Metric
coherence_metric = GEval(
    title="Coherence",
    standards="Coherence. The agent can reply the immediate and the response is sensible.",
    evaluation_params=[LLMTestCaseParams.ACTUAL_OUTPUT]
)

# Run the metric
coherence_metric.measure(test_case)
print(coherence_metric.rating)
print(coherence_metric.motive)

The output seems to be like this.

0.9
The response instantly addresses the immediate about NYC climate in Might, 
maintains logical consistency, flows naturally, and makes use of clear language. 
Nevertheless, it might be barely extra detailed.

0.9 appears fairly good, provided that the default threshold is 0.5.

If you wish to verify the logs, use this subsequent snippet.

# Examine the logs
print(coherence_metric.verbose_logs)

Right here’s the response.

Standards:
Coherence. The agent can reply the immediate and the response is sensible.

Analysis Steps:
[
    "Assess whether the response directly addresses the prompt; if it aligns,
 it scores higher on coherence.",
    "Evaluate the logical flow of the response; responses that present ideas
 in a clear, organized manner rank better in coherence.",
    "Consider the relevance of examples or evidence provided; responses that 
include pertinent information enhance their coherence.",
    "Check for clarity and consistency in terminology; responses that maintain
 clear language without contradictions achieve a higher coherence rating."
]

Very good. Now allow us to study one other attention-grabbing use case, which is the analysis of process completion for AI Brokers. Elaborating just a little extra, how our agent is doing when it’s requested to carry out a process, and the way a lot of it the agent can ship.

First, we’re making a easy agent that may entry Wikipedia and summarize the subject of the question.

# Imports
from agno.agent import Agent
from agno.fashions.google import Gemini
from agno.instruments.wikipedia import WikipediaTools
import os
from deepeval.test_case import LLMTestCase, ToolCall
from deepeval.metrics import TaskCompletionMetric
from deepeval import consider

# Immediate
immediate = "Search wikipedia for 'Time sequence evaluation' and summarize the three details"

# Create agent
agent = Agent(
    mannequin= Gemini(id="gemini-2.0-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
    description= "You're a researcher specialised in looking out the wikipedia.",
    instruments= [WikipediaTools()],
    show_tool_calls= True,
    markdown= True,
    read_tool_call_history= True
    )

# Run agent
response = agent.run(immediate)

# Print response
print(response.content material)

The consequence seems to be superb. Let’s consider it utilizing the TaskCompletionMetric class.

# Create a Metric
metric = TaskCompletionMetric(
    threshold=0.7,
    mannequin="gpt-4o-mini",
    include_reason=True
)

# Check Case
test_case = LLMTestCase(
    enter=immediate,
    actual_output=response.content material,
    tools_called=[ToolCall(name="wikipedia")]
    )

# Consider
consider(test_cases=[test_case], metrics=[metric])

Output, together with the agent’s response.

======================================================================

Metrics Abstract

  - ✅ Activity Completion (rating: 1.0, threshold: 0.7, strict: False, 
analysis mannequin: gpt-4o-mini, 
motive: The system efficiently looked for 'Time sequence evaluation' 
on Wikipedia and offered a transparent abstract of the three details, 
absolutely aligning with the person's objective., error: None)

For check case:

  - enter: Search wikipedia for 'Time sequence evaluation' and summarize the three details
  - precise output: Listed here are the three details about Time sequence evaluation primarily based on the
 Wikipedia search:

1.  **Definition:** A time sequence is a sequence of knowledge factors listed in time order,
 typically taken at successive, equally spaced cut-off dates.
2.  **Functions:** Time sequence evaluation is utilized in varied fields like statistics,
 sign processing, econometrics, climate forecasting, and extra, wherever temporal 
measurements are concerned.
3.  **Goal:** Time sequence evaluation includes strategies for extracting significant 
statistics and traits from time sequence knowledge, and time sequence forecasting 
makes use of fashions to foretell future values primarily based on previous observations.

  - anticipated output: None
  - context: None
  - retrieval context: None

======================================================================

General Metric Go Charges

Activity Completion: 100.00% go fee

======================================================================

✓ Exams completed 🎉! Run 'deepeval login' to save lots of and analyze analysis outcomes
 on Assured AI.

Our agent handed the check with honor: 100%!

You’ll be able to be taught way more in regards to the DeepEval library on this hyperlink [8].

Lastly, within the subsequent part, we’ll be taught the capabilities of Agno’s library for monitoring brokers.

Agent Monitoring

Like I advised you in my earlier put up [9], I selected Agno to be taught extra about Agentic AI. Simply to be clear, this isn’t a sponsored put up. It’s simply that I believe that is the most suitable choice for these beginning their journey studying about this matter.

So, one of many cool issues we are able to reap the benefits of utilizing Agno’s framework is the app they make out there for mannequin monitoring.

Take this agent that may search the web and write Instagram posts, for instance.

# Imports
import os
from agno.agent import Agent
from agno.fashions.google import Gemini
from agno.instruments.file import FileTools
from agno.instruments.googlesearch import GoogleSearchTools


# Subject
matter = "Wholesome Consuming"

# Create agent
agent = Agent(
    mannequin= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
                  description= f"""You're a social media marketer specialised in creating partaking content material.
                  Search the web for 'trending subjects about {matter}' and use them to create a put up.""",
                  instruments=[FileTools(save_files=True),
                         GoogleSearchTools()],
                  expected_output="""A brief put up for instagram and a immediate for an image associated to the content material of the put up.
                  Do not use emojis or particular characters within the put up. For those who discover an error within the character encoding, take away the character earlier than saving the file.
                  Use the template:
                  - Publish
                  - Immediate for the image
                  Save the put up to a file named 'put up.txt'.""",
                  show_tool_calls=True,
                  monitoring=True)

# Writing and saving a file
agent.print_response("""Write a brief put up for instagram with ideas and methods that positions me as 
                     an authority in {matter}.""",
                     markdown=True)

To watch its efficiency, observe these steps:

Go to https://app.agno.com/settings and get an API Key.
Open a terminal and kind ag setup.
If it’s the first time, it would ask for the API Key. Copy and Paste it within the terminal immediate.
You will note the Dashboard tab open in your browser.
If you wish to monitor your agent, add the argument monitoring=True.
Run your agent.
Go to the Dashboard on the net browser.
Click on on Classes. As it’s a single agent, you will notice it beneath the tab Brokers on the highest portion of the web page.

Agno Dashboard after working the agent. Picture by the creator.

The cools options we are able to see there are:

Data in regards to the mannequin
The response
Instruments used
Tokens consumed

That is the ensuing token consumption whereas saving the file. Picture by the creator.

Fairly neat, huh?

That is helpful for us to know the place the agent is spending roughly tokens, and the place it’s taking extra time to carry out a process, for instance.

Nicely, let’s wrap up then.

Earlier than You Go

We’ve got realized loads on this second spherical. On this put up, we coated:

Guardrails for AI are important security measures and moral pointers applied to forestall unintended dangerous outputs and guarantee accountable AI conduct.
Mannequin analysis, exemplified by GEval for broad evaluation and TaskCompletion with DeepEval for brokers output high quality, is essential for understanding AI capabilities and limitations.
Mannequin monitoring with Agno’s app, together with monitoring token utilization and response time, which is important for managing prices, guaranteeing efficiency, and figuring out potential points in deployed AI programs.