Introduction

AI agents are the future and can be the driving force for the future. They are the future and can be the driving force for the future. AI agents are becoming increasingly important for the growth of AI and new technological developments. They are applications that reflect human characteristics to interact, reason and even make appropriate decisions to achieve certain goals with advanced autonomy and perform multiple tasks in real time, which was impossible with LLMs.

In this article, we will dive into the details of AI agents and how to build AI agents using LlamaIndex and MonsterAPI tools. LlamaIndex provides a set of tools and abstractions to easily develop AI agents. We will also use MonsterAPI for LLM APIs to build agentic applications with real-world examples and demos.

Learning objectives

• Learn the concept and architecture of agentic AI applications to implement such applications in real-world problem scenarios.
• Understand the difference between large language models and AI agents based on their core capabilities, features, and benefits.
• Understand the core components of AI agents and their interactions with each other when developing agents.
• Explore the wide range of use cases of AI agents from different industries to apply such concepts.

This article was published as part of the Data Science Blogathon.

What are AI agents?

AI agents are autonomous systems designed to mimic human behavior, allowing them to perform tasks that mimic human thinking and observations. Agents interact with an environment in combination with LLMs, tools, and memory to perform various tasks. AI agents differ from large language models in their work and process of generating output. Explore the key characteristics of AI agents and compare them with LLMs to understand their unique roles and functionalities.

• AI agents think like humans: AI agents use tools to perform specific functions to produce a certain output. For example, search engine, database search, calculator, etc.
• AI agents behave like humans: AI agents, like humans, plan actions and use tools to achieve specific outcomes.
• AI agents observe just like humans: Using planning frameworks, agents respond, reflect, and take actions appropriate to given inputs. Memory components enable AI agents to remember previous steps and actions, so that AI agents can efficiently produce desired outputs.

Let’s look at the key difference between LLMs and AI agents to make a clear distinction between the two.

Working with AI agents

Agents are developed from a set of components, mainly the memory layer, tools, models and reasoning loops that work in orchestration to achieve a set of tasks or some specific tasks that the user may want to solve. For example, using a weather agent to extract real-time weather data with the user’s voice or text command. Let’s learn more about each component to build AI agents:

• Reasoning loop: The reasoning loop is at the heart of AI agents to plan actions and enable decision-making for processing inputs. It then refines the output data to produce the desired results at the end of the loop.
• Memory layer: Memory is a crucial part of the AI ​​agents to remember planning, thoughts and actions while processing the user input to generate certain outcomes. Memory can be short-term or long-term depending on a problem.
• Models: Large language models help synthesize and generate results in a way that humans can interpret and understand.
• Resources: These are external built-in functions that agents use to perform specific tasks, such as retrieving data from databases and APIs. They can also retrieve real-time weather data or perform calculations with a calculator.

Interaction between components

The Reasoning Loop continuously communicates with both the Model and the Tools. The loop uses the outputs of the Model to inform decisions, while the Tools are used to respond to those decisions.

This interaction forms a closed loop in which data flows between the components, allowing the agent to process information, make informed decisions, and seamlessly take appropriate action.

Let’s look at the use cases of AI agents and then move on to live code examples of AI agents using MonsterAPIs.

Usage patterns in AI agents

LlamaIndex provides high-quality tools and classes that allow you to develop AI agents without worrying about execution and deployment.

In the reasoning loop, LlamaIndex provides function calling agents that integrate well with LLMs, ReAct Agents, Vector repositories, and advanced agents to build effective working agentic applications from prototype to production.

In LlamaIndex, agents are developed in the following pattern. We will look at the development of the AI ​​agent later in the blog:

from llama_index.agent.openai import OpenAIAgent
from llama_index.llms.openai import OpenAI

# import and define tools
# Define functions and tools to interact with agent


# initialize llm
llm = OpenAI(model="gpt-3.5-turbo-0613")

# initialize openai agent
agent = OpenAIAgent.from_tools(tools, llm=llm, verbose=True)

AI Agent Use Cases

AI agents have a wide range of real-world use cases to perform common tasks and improve time efficiency while increasing revenue for businesses. Some of the common use cases are as follows:

• Agentic RAG: Building a contextually rich system to leverage industry-specific datasets for better response to user queries and more accurate answers to given input questions.
• SQL Agent: Text to SQL is another use case where agents use LLMs and databases to generate automated SQL queries, thereby generating user-friendly output without writing a SQL query.
• Workflow Assistant: Build an agent that can interoperate with common workflow assistants such as weather APIs, calculators, calendars, etc.
• Code Assistant: Assistant who helps in reviewing, writing and improving the code writing experience for the developers.
• Content Curation: AI agents can suggest personalized content, such as articles and blog posts, and can also summarize the information for users.
• Automated trading: AI agents can collect real-time market data, including sentiment analysis, and automatically trade to maximize profits for companies.
• Threat Detection: AI agents can monitor network traffic, identify potential security risks, and respond to cyberattacks in real time, thereby improving an organization’s cybersecurity.

Building Agentic RAG using LlamaIndex and MonsterAPI

In this section, we will explore the agentic RAG application using LlamaIndex tools and MonsterAPI to access large language models. Before diving into the code, let’s first look at the overview of a MonsterAPI platform.

Overview of a MonsterAPI

MonsterAPI is an easy-to-use no-code/low-code tool that simplifies deployment, tuning, testing, evaluation, and bug management for large language model-based applications including AI agents. It is less expensive compared to other cloud platforms and is FREE to use for personal projects or research work. It supports a wide range of models such as text generation, image generation, and code generation models. In our example, MonsterAPI model APIs can access the custom dataset stored using LlamaIndex rich response vector storage to use queries against a newly added dataset.

Step 1: Install libraries and set up an environment

First, we install the necessary libraries and modules, including MonsterAPI LLMs, LlamaIndex agents, embeddings, and vector stores for further development of the agent. Also, sign up for FREE on the MonsterAPI platform to get the API key to access the large language model.

# install necessary libraries
%pip install llama-index-llms-monsterapi
!python3 -m pip install llama-index --quiet
!python3 -m pip install monsterapi --quiet
!python3 -m pip install sentence_transformers --quiet

!pip install llama-index-embeddings-huggingface
!python3 -m pip install pypdf --quiet
!pip install pymupdf

import os
import os
from llama_index.llms.monsterapi import MonsterLLM
from llama_index.core.embeddings import resolve_embed_model
from llama_index.core.node_parser import SentenceSplitter
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
import fitz  # PyMuPDF

# set up your FREE MonsterAPI key to access to models 
os.environ("MONSTER_API_KEY") = "YOUR_API_KEY"

Step 2: Set the model with MonsterAPI

Once the environment is set up, load the Meta Llama-3-8B-Instruct model instance using LlamaIndex to call the model API. Test the model API by running a sample query on the model.

Why use the Llama-3-8B-instruct model?

Llama-3-8B is one of the newest models released by Meta that outperforms models in its category on many benchmark metrics, such as MMLU, knowledge reasoning, and reading comprehension. It is an accurate and efficient model for practical purposes with lower computational requirements.

# create a model instance
model = "meta-llama/Meta-Llama-3-8B-Instruct"

# set a MonsterAPI instance for model
llm = MonsterLLM(model=model, temperature=0.75)

# Ask a general query to LLM to ensure model is loaded
result = llm.complete("What's the difference between AI and ML?")

Step 3: Load the documents and set Vectorstoreindex for AI agent

Now we load the documents and store them in a vector store index object of LlamaIndex. Once the data is vectorized and stored, we can issue queries to the LlamaIndex query engine which will use LLM instance of MonsterAPI, VectorstoreIndex and Memory to generate a suitable response with the suitable integration available.

# store the data in your local directory 
!mkdir -p ./data
!wget -O ./data/paper.pdf https://arxiv.org/pdf/2005.11401.pdf

# load the data using LlamaIndex's directory loader
documents = SimpleDirectoryReader(input_dir="./data").load_data()

# Load the monsterAPI llms and embeddings model
llm = MonsterLLM(model=model, temperature=0.75)
embed_model = resolve_embed_model("local:BAAI/bge-small-en-v1.5")
splitter = SentenceSplitter(chunk_size=1024)

# vectorize the documents using a splitter and embedding model
index = VectorStoreIndex.from_documents(
    documents, transformations=(splitter), embed_model=embed_model
)

# set up a query engine
query_engine = index.as_query_engine(llm=llm)

# ask a query to the RAG agent to access custom data and produce accurate results
response = query_engine.query("What is Retrieval-Augmented Generation?")

Finally, we developed our RAG agent, which uses amended data to answer user questions that traditional models cannot accurately answer. As shown above, the refined RAG query consumes new documents using the LlamaIndex vector store and MonsterAPI LLM by asking questions to the query engine.

Conclusion

AI agents are changing the way we interact with AI technologies by deploying AI assistants, tools that mimic human thought and behavior to perform tasks autonomously.

We learned what AI agents are, how they work, and many real-world use cases of such agents. Agents mainly contain memory layers, reasoning loops, models, and tools to achieve desired tasks without much human intervention.

By leveraging powerful frameworks like LlamaIndex and MonsterAPI, we can build capable agents that can retrieve, augment, and generate personalized context-specific responses for users in any domain or industry. We also saw a practical agentic RAG example that can be used for many applications. As these technologies continue to evolve, the possibilities for creating more autonomous and intelligent applications will increase many times over.

Key Points

• I learned about autonomous agents and their working methodology that mimics human behavior and performance to increase productivity and improve tasks.
• We understood the fundamental difference between large language models and AI agents and their applicability in real-world problem scenarios.
• Gained insight into the four key components of AI agents, such as reasoning loop, tools, models, and memory layer, which form the basis of all AI agents.

Frequently Asked Questions

The media shown in this article is not owned by Analytics Vidhya and is used at the author’s sole discretion.