AI ENGINEER

Basic Agentic AI System Building

Course Overview

Build a strong foundation in Agentic AI System Development through a practical, beginner-friendly learning journey.

This course takes students from essential Python programming to building AI applications that can understand requests, use tools, access external data, make decisions, and complete multi-step tasks.

You will learn how to connect LLMs, APIs, databases, RAG systems, tools, memory, and agent workflows to build a complete basic AI agent.

Who Is This Course For?

• Beginners interested in AI agents
• Computer Science, AI, Software Engineering, and IT students
• Developers who want to add AI agents to applications
• Students building AI-based FYPs
• Anyone interested in automating real-world tasks using AI
• Learners with little or no previous AI experience

What You Will Learn

1. Python Foundations for AI Agents

• Python fundamentals
• Variables and data types
• Conditions and loops
• Functions and reusable code
• Lists, dictionaries, tuples, and sets
• Object-oriented programming basics
• Error handling and debugging
• Working with files and JSON
• Environment variables and API keys
• Installing and managing Python packages
• Virtual environments

Practical project: Build a command-line task assistant in Python.

2. APIs and Backend Fundamentals

• What APIs are and how they work
• HTTP requests and responses
• GET, POST, PUT, and DELETE methods
• Working with JSON data
• Calling external APIs with Python
• API authentication
• Handling API errors
• Introduction to FastAPI
• Creating backend endpoints
• Connecting a frontend with an AI backend

Practical project: Build a FastAPI application that retrieves and processes data from an external API.

3. Generative AI and Large Language Models

• What generative AI is
• What Large Language Models are
• How LLMs process user instructions
• Tokens and context windows
• Model limitations and hallucinations
• Working with LLM APIs
• Sending prompts and receiving responses
• Managing conversation history
• Choosing models for different tasks
• Understanding model cost and latency

Practical project: Build a conversational AI assistant using an LLM API.

4. Prompt Engineering and Structured Outputs

• System, user, and assistant messages
• Writing effective instructions
• Zero-shot and few-shot prompting
• Providing examples and context
• Controlling tone and response format
• Generating structured JSON responses
• Validating AI-generated data
• Prompt templates
• Guardrails and input restrictions
• Reducing hallucinations

Practical project: Build an AI assistant that extracts structured information from natural-language requests.

5. Tool and Function Calling

• What tools are in agentic systems
• Difference between an LLM and an AI agent
• Defining tools and their parameters
• Function calling
• Allowing AI to select the correct tool
• Executing tools safely
• Returning tool results to the model
• Handling tool failures
• Connecting agents with business APIs
• Creating multiple tools for one agent

Example tools:

• Check appointment availability
• Create a booking
• Search a product
• Check order status
• Send an email
• Retrieve customer information

Practical project: Build an AI assistant that chooses and executes the correct business tool.

6. RAG and Knowledge-Based Agents

• What Retrieval-Augmented Generation is
• Why LLMs need external knowledge
• Document loading and processing
• Text chunking
• Embeddings
• Semantic search
• Vector databases
• Retrieving relevant information
• Adding retrieved context to an LLM
• Including sources in AI answers
• Reducing knowledge-based hallucinations

Practical project: Build a document-question-answering assistant using private business information.

7. Memory and Conversation Management

• Short-term conversation memory
• Long-term memory concepts
• Session and user identification
• Storing conversation history
• Managing context-window limits
• Summarizing older conversations
• Saving user preferences
• Database-backed memory
• Protecting sensitive user information
• Deciding what the agent should remember

Practical project: Build an AI assistant that remembers users and continues previous conversations.

8. Agent Workflows and Decision-Making

• What makes an AI system agentic
• Agent goals and instructions
• Reasoning and action cycles
• Planning multi-step tasks
• Selecting tools based on user intent
• Conditional workflows
• Maintaining agent state
• Handling failed actions
• Human approval before sensitive actions
• Preventing infinite agent loops
• Setting action and iteration limits

Example workflow:

```text
User Request
↓
Understand Intent
↓
Retrieve Required Information
↓
Select the Correct Tool
↓
Check Permission
↓
Perform the Action
↓
Verify the Result
↓
Respond to the User
```

Practical project: Build an agent that completes a multi-step task using multiple tools.

9. Building Agentic Systems with Frameworks

• Agent development with plain Python
• Introduction to LangChain
• Introduction to LangGraph
• Nodes, edges, and workflow state
• Sequential and conditional workflows
• Tool-calling agents
• Creating reliable agent flows
• When to use frameworks
• When a simple Python workflow is better
• Introduction to multi-agent systems

Practical project: Build a stateful agent workflow using LangGraph.

10. Agent Safety, Permissions, and Observability

• Authentication and authorization
• Tool-access permissions
• Input validation
• Protecting API keys
• Prompt-injection risks
• Preventing unauthorized actions
• Requiring human approval
• Logging conversations and tool calls
• Tracking agent decisions
• Monitoring token usage and costs
• Testing agent responses
• Creating an audit trail

Example permission policy:

```text
View appointments → Allowed
Create appointments → Allowed
Reschedule appointments → Confirmation required
Cancel appointments → Staff approval required
Issue refunds → Not allowed
```

Practical project: Add permissions, approval rules, and activity logs to an AI agent.

11. Deploying an AI Agent

• Organizing an agentic AI project
• Connecting the agent to FastAPI
• Database integration
• Managing environment variables
• Testing API endpoints
• Handling multiple users
• Basic deployment concepts
• Deploying the backend
• Connecting the agent to a web application
• Monitoring errors and performance
• Managing API usage and cost

Practical project: Deploy an AI-agent backend and connect it to a basic web interface.

Final Course Project

Students will build a Basic AI Business Agent for a clinic, restaurant, educational institute, e-commerce store, or another selected business.

The agent will be able to:

• Understand natural-language requests
• Answer questions using business knowledge
• Retrieve information through RAG
• Use multiple tools
• Perform basic business actions
• Maintain conversation context
• Store data in a database
• Request confirmation before important actions
• Handle failures safely
• Record conversations and tool activity
• Provide responses through a FastAPI backend

Example: Clinic Appointment Agent

```text
Patient requests an appointment
↓
Agent understands the request
↓
Agent retrieves doctor information
↓
Agent checks available time slots
↓
Patient selects a suitable time
↓
Agent asks for confirmation
↓
Appointment is created
↓
Action is stored in the database
↓
Confirmation is returned
```

Practical Projects

Throughout the course, students will build:

• Python task assistant
• External API integration
• LLM-powered chatbot
• Structured-data extraction system
• Tool-calling AI assistant
• RAG knowledge assistant
• Memory-enabled chatbot
• Multi-step agent workflow
• Secure agent with permission controls
• Final AI business agent

What You Will Gain

By the end of the course, students should be able to:

• Write Python code for AI applications
• Work with APIs and JSON data
• Build AI backends using FastAPI
• Integrate Large Language Models
• Design effective prompts
• Generate and validate structured outputs
• Create tools that agents can use
• Build basic RAG systems
• Add memory to AI applications
• Design multi-step agent workflows
• Apply permissions and safety controls
• Log and monitor agent actions
• Build and deploy a basic agentic AI system
• Start developing AI-based FYP and portfolio projects

Learning Approach

Understand the concept. Build the component. Connect the system.

Each module adds one important component to the final agent:

```text
Python
↓
APIs
↓
LLMs
↓
Structured Outputs
↓
Tools
↓
RAG
↓
Memory
↓
Agent Workflows
↓
Safety and Permissions
↓
Complete Agentic AI System
```

The course prioritizes practical system building while explaining how each component works.

Prerequisites

• Basic computer knowledge
• No advanced AI knowledge required
• Previous programming experience is helpful but not mandatory
• A laptop or computer with internet access
• Willingness to practise and build projects

Course Outcome

This course provides a practical foundation for progressing into:

• Advanced AI agents
• Multi-agent systems
• Voice AI agents
• Autonomous workflows
• Advanced RAG systems
• Local and open-source AI models
• AI business automation
• Production AI applications
• AI-powered SaaS development

Start Building Agentic AI Systems

Move beyond basic chatbots and learn how to create AI applications that can understand, retrieve, decide, act, and verify.

From Python fundamentals to a working AI agent—one component at a time.

• Attend sessions regularly and actively participate in practical activities.
• Complete assignments and projects within the given deadlines.
• Practice concepts independently and build projects instead of only watching lectures.
• AI tools such as ChatGPT may be used for learning and debugging, but understand the code before using it.
• Maintain professional conduct, communicate respectfully, and follow all course instructions.