From LLMs to AI Agents: Building My First AI Agent

Introduction

The AI landscape is rapidly evolving from simple chatbots to intelligent agents capable of reasoning, planning, remembering, and taking actions. Technologies such as Large Language Models (LLMs), Retrieval-Augmented Generation (RAG), Memory, and AI Agents are enabling a new generation of enterprise applications.

In this blog, we'll explore these concepts and build a simple AI Agent using LangChain.

What is an LLM?

A Large Language Model (LLM) is the foundation of modern Generative AI. It is trained on vast amounts of text and code data and learns language patterns, reasoning, and problem-solving capabilities.

Examples include:

• GPT

• Claude

• Gemini

• Llama

Think of the LLM as the Brain of an AI system.

Simple LLM Example

from langchain.chat_models import init_chat_model 
model = init_chat_model("openai:gpt-5.5") 
response = model.invoke( 
    "What is LangChain in one sentence?" 
) 
print(response.content)

Here, the model receives a question and generates a response based on its training.

What is Pre-Training?

Pre-training is the process of teaching an LLM using massive datasets containing:

• Books

• Websites

• Research Papers

• Documentation

• Source Code

During pre-training, the model learns:

• Language structure

• General knowledge

• Reasoning patterns

• Programming concepts

Think of pre-training as a student attending school and learning fundamentals before entering a profession.

What is RAG?

RAG stands for Retrieval-Augmented Generation.

Instead of relying solely on information learned during training, a RAG system retrieves relevant documents from an external knowledge source and passes them to the model before generating an answer.

Traditional LLM

User Question 
      │ 
      ▼ 
     LLM 
      │ 
      ▼ 
    Answer

RAG Architecture

User Question 
      │ 
      ▼ 
Knowledge Search 
      │ 
      ▼ 
Relevant Documents 
      │ 
      ▼ 
     LLM 
      │ 
      ▼ 
    Answer

Benefits of RAG

✅ Real-time knowledge

✅ Access to enterprise documentation

✅ Reduced hallucinations

✅ More accurate responses

✅ No retraining required

Why Memory Matters

By default, LLMs are stateless.

They do not remember previous conversations unless context is provided.

Memory enables an AI application to maintain context and personalize responses.

Memory Example:

from langchain_core.chat_history import InMemoryChatMessageHistory 
memory = InMemoryChatMessageHistory()

Conversation:

User: My name is Alex 
 
Assistant: Nice to meet you Alex 
 
User: What is my name?

Response : Your name is Alex.

Benefits of Memory

• Personalized interactions

• Context retention

• Improved user experience

• Multi-step workflows

Agent = Brain + Hands + Nervous System

One of the simplest ways to understand AI Agents is:

Agent = LLM + Tools + Loop

Or

Agent = Brain + Hands + Nervous System

LLM = Brain

Responsible for:

• Thinking

• Planning

• Understanding

• Reasoning

Tools = Hands

Responsible for:

• Searching

• Calling APIs

• Running scripts

• Querying databases

• Performing calculations

Loop = Nervous System

Responsible for:

• Coordinating thinking and actions

• Observing tool outputs

• Deciding next steps

The loop continuously performs:

Think 
   ↓ 
Choose Tool 
   ↓ 
Execute Tool 
   ↓ 
Observe Result 
   ↓ 
Think Again 
   ↓ 
Respond

Benefits of AI Agents Over Traditional LLMs

Capability	LLM	Agent
Answer Questions	✅	✅
Use Tools	❌	✅
Multi-Step Reasoning	Limited	✅
Execute Actions	❌	✅
Memory	Limited	✅
Workflow Automation	❌	✅
Query Databases	❌	✅
API Integration	❌	✅

Traditional LLMs provide information.

AI Agents deliver outcomes.

Building My First AI Agent

To understand Agentic AI, let's build a simple calculator agent.

Create a virtual environment

python -m venv langchain-env

source langchain-env/bin/activate

Install packages

pip install langchain langchain-openai langgraph

pip install python-dotenv

Set your API key in a .env file

OPENAI_API_KEY=sk-your-key-here

My First Agent - Calculator

from langchain.chat_models import init_chat_model

from langchain.agents import create_agent

from langchain_core.tools import tool

# 1. Initialize the model

model = init_chat_model("openai:gpt-4o")

# 2. Define your tools

@tool

def multiply(a: float, b: float) -> float:

"""Multiply two numbers together. Use for multiplication operations."""

return a * b

@tool

def divide(a: float, b: float) -> float:

"""Divide the first number by the second. Returns error if dividing by zero."""

if b == 0:

return "Error: Cannot divide by zero"

return a / b

# 3. Create the LangChain Agent – that's it!

agent = create_agent(model, [multiply, divide])

# 4. Run it

result = agent.invoke({

"messages": [

("user", "What is 15 multiplied by 8, then divided by 3?")

]

})

print(result)

What Happens Behind the Scenes?

User Question 
        │ 
        ▼ 
   LLM Thinks 
        │ 
        ▼ 
Calls Multiply 
15 × 8 = 120 
        │ 
        ▼ 
  Calls Divide 
120 ÷ 3 = 40 
        │ 
        ▼ 
Final Answer 

The agent determines which tools to use, executes them, and produces the final response.

The Future of AI

The evolution of AI is moving through four major stages:

Pre-Training 
      ↓ 
Fine-Tuning 
      ↓ 
RAG 
      ↓ 
Agents 
      ↓ 
Multi-Agent Systems

Future enterprise AI solutions will combine:

• LLMs for reasoning

• RAG for knowledge retrieval

• Memory for context

• Agents for execution

This combination enables AI systems that don't just answer questions but can take meaningful actions and solve real business problems.

Conclusion

The journey from LLMs to AI Agents represents a significant shift in how AI systems operate. Pre-training provides foundational knowledge, RAG connects AI to real-world information, memory provides context, and agents bring decision-making and action-taking capabilities.

The simplest way to remember this is:

Agent = LLM (Brain) 
       + Tools (Hands) 
       + Loop (Nervous System)

Once these three components work together, AI moves beyond conversation and becomes capable of delivering outcomes, automating workflows, and acting as a true digital assistant.