Agentic AI Explained

LLM stands for Large Language Model.

A Large Language Model is an Artificial Intelligence system trained on massive amounts of text data so it can understand, generate, summarize, translate and reason using human language.

Think of an LLM as a super-smart digital brain that has read billions of documents, books, articles, websites and conversations.

Examples include ChatGPT, Gemini, Claude, Llama and Grok.

Before LLMs, computers followed fixed rules.

They could not easily understand human language.

LLMs changed this by allowing computers to:

• Understand natural language
• Answer questions
• Write essays
• Generate code
• Translate languages
• Summarize documents
• Act as virtual assistants

Step 1: Collect Massive Data

Books, websites, articles, code repositories and research papers.

Step 2: Clean Data

Remove spam, duplicates and low-quality content.

Step 3: Tokenization

Convert words into tokens.

Step 4: Pretraining

Predict missing or next words billions of times.

Step 5: Fine Tuning

Improve model on specific tasks.

Step 6: Human Feedback

Humans rank answers to improve quality.

🔗 From LLMs to AI Agents

LLMs are powerful brains that can understand and generate language.

However, LLMs alone mostly generate responses.

To perform actions such as searching the web, reading PDFs, sending emails, booking tickets, or analyzing files, we need AI Agents.

This is where the next evolution begins: AI Agents and Agentic AI.

🔗 From LLMs to AI Agents

LLMs are powerful brains that can understand and generate language.

However, LLMs alone mostly generate responses.

To perform actions such as searching the web, reading PDFs, sending emails, booking tickets, or analyzing files, we need AI Agents.

This is where the next evolution begins: AI Agents and Agentic AI.

Imagine you are asked to organize a school science exhibition.

You cannot do everything yourself.

You need different people to help you.

• One student creates posters.
• One student manages registrations.
• One student arranges chairs.
• One student handles announcements.
• One student prepares certificates.

All these students work together to complete one goal.

Agentic AI works exactly the same way.

Instead of students, we have AI Agents.

Each agent specializes in a specific task.

Together they solve complex problems.

Traditional AI

Traditional AI systems answer questions.

Example:

User: "What is the capital of France?"

AI: "Paris"

Task completed.

---

Complex Goal

Now imagine asking:

"Plan a 5-day vacation to Goa with a budget under ₹30,000."

This requires:

• Searching flights
• Finding hotels
• Calculating costs
• Planning activities
• Preparing schedules

One AI response is not enough.

Agentic AI solves such complex goals.

Step 1: Understand Goal

The AI first understands what the user wants.

Example: "Build a website."

Step 2: Create a Plan

The AI creates a roadmap.

• Create design
• Create frontend
• Create backend
• Connect database
• Deploy website

Step 3: Assign Tasks

Different agents receive different responsibilities.

Step 4: Execute Tasks

Agents start working independently.

Step 5: Review Results

Results are checked for errors.

Step 6: Final Output

User receives completed work.

Memory is one of the most important parts of Agentic AI.

Without memory, the AI would forget everything after every step.

Memory helps agents remember:

• User preferences
• Past conversations
• Completed tasks
• Research findings
• Previous decisions

This makes the system smarter and more efficient.

Humans often review their work before submitting it.

Agentic AI does the same thing.

After completing a task, agents can review:

• Did we miss anything?
• Did we make mistakes?
• Can the answer be improved?

This process is called Reflection.

Reflection helps improve accuracy and reliability.

Project Goal

Upload a blood report and let AI analyze the report, identify abnormalities, explain medical terms, detect health risks, and provide recommendations.

Instead of reading a complex medical report, users receive a simple understandable explanation.

🎯 Project Objective

The goal of this project is to automatically analyze blood reports and provide easy-to-understand explanations.

Instead of manually reading complex medical reports, users simply upload a PDF report and receive an AI-generated analysis.

This project demonstrates how multiple AI agents can collaborate to solve a healthcare-related problem.

🎯 Project Objective

In this project, we will build an Agentic AI application that can automatically analyze blood reports and generate easy-to-understand medical explanations.

Instead of manually reading complicated medical reports, users simply upload a PDF file and receive a complete AI-generated health analysis.

This project demonstrates how multiple AI agents collaborate to solve a real-world healthcare problem.

Before using Llama 3, we need access to Groq's AI servers.

Follow These Steps

1. Visit: https://console.groq.com
2. Create a free Groq account.
3. Verify your email.
4. Login to the Groq Console.
5. Navigate to API Keys.
6. Click Create API Key.
7. Give the key a name.
8. Copy and save the API Key.

1. Open Google Colab
2. Create a New Notebook
3. Rename it as: Blood_Report_Analyzer
4. Install required libraries

!pip install gradio
!pip install groq
!pip install pdfplumber

import gradio as gr
import pdfplumber
from groq import Groq

def extract_text(pdf_file):

    text = ""

    with pdfplumber.open(pdf_file) as pdf:

        for page in pdf.pages:

            text += page.extract_text()

    return text

client = Groq(
    api_key="YOUR_API_KEY"
)

def analyze_report(report_text):

    prompt = f'''
    Analyze this blood report.

    Explain:
    1. Important blood values
    2. Abnormal values
    3. Health risks
    4. Recommendations

    {report_text}
    '''

    response = client.chat.completions.create(
        model="llama3-8b-8192",
        messages=[
            {
                "role":"user",
                "content":prompt
            }
        ]
    )

    return response.choices[0].message.content

def process(pdf):

    text = extract_text(pdf)

    result = analyze_report(text)

    return result

gr.Interface(
    fn=process,
    inputs=gr.File(),
    outputs=gr.Textbox(),
    title="AI Blood Report Analyzer"
).launch()

🎓 Learning Outcomes

• Understanding Agentic AI
• Building Multi-Agent Systems
• Using Groq API
• Working with Llama 3
• PDF Processing
• Prompt Engineering
• Creating Gradio Applications
• Healthcare AI Applications
• Real-World AI Project Development

Congratulations! 🎉 You have successfully learned how Agentic AI can be used to solve a real-world healthcare problem.