
Build an autonomous ai agent from scratch using open source tools that can search the web, analyze documents, remember conversations, and decide intelligently.
Learn what an AI agent is, how it thinks and acts autonomously, and how it differs from traditional apps, using Lama Lang Chain, Croma, DB, and Streamlit.
See how autonomous AI agents perceive input from users and data sources, reason through steps with tools, and act in a continuous feedback loop to achieve goals.
Explore the four core components powering ai agents—the model, memory, tools, and environment—and how memory uses Chroma DB with Lang Chain to connect to tools.
Explore open-source options to build AI agents locally using Olama for local reasoning, long chain to access tools and APIs, and Chroma DB for semantic memory.
Install Python, Lama Lang, Lang Chain, and Streamlit, then set up Visual Studio Code to build and test your AI agent locally.
Test your local ai setup in Visual Studio Code with Olama, run the query offline against the llama three model, and confirm a local model ready for Lang Chain integration.
Explore the main types of AI agents, from reactive to proactive and tool using, then see how LangChain enables multi-agent collaboration for complex tasks.
Choose the right agent with memory for a book finder app, using Open Library API and Lang Chain to fetch live data, understand user queries, and remember preferences.
See how a Streamlit UI sends a query to a llama-powered model, then via planner and tool router fetches from Open Library and uses chroma memory to craft an answer.
Discover how a vector database stores meaning as embeddings, outperforming SQL by enabling memory-like retrieval with Chroma DB.
Contrast vector databases with normal SQL, emphasizing meaning-based memory retrieval, semantic search, and similarity matching. Explain embedding handling by tools like chroma db for AI agents.
Compare sql and vector databases by showing how sql inserts store text, while Chroma converts data into embeddings and indexes it for meaning-based retrieval.
Set up the ai agent environment in VS Code by creating a virtual environment, installing packages, and running the llama 3 model; prepare memory with chroma db and embeddings.
Connect to the chroma db memory system by importing the required package, creating a persistent client and a book memory collection, and verifying the database folder for permanent storage.
Fetch book data from the Open Library API with Python requests, extract title, author, year, and description, and build a memory-ready list the agent can reason with using chroma.
Format raw results into a text block using a pretty_raw_results function that extracts title, author, and description with safe fallbacks and hyphen lines, and test by removing the first hyphen.
This lecture shows how to give an agent lasting memory by fetching books, storing summaries with unique user-based ids on disk via Chroma, persisting data, and recalling similar items.
connect the agent to a local llm running on ollama, enabling its thoughts and replies to flow through this chat function.
Create an intent extraction and formatting pipeline using prompt and formatting templates to fuel the intent chain and format chain, understand user goals, and deliver neat, readable book results.
Build a tiny planner and full agent logic that processes messages end to end, using intent extraction, tool selection (open library), memory tagging, and a formatter chain for clear replies.
Create a real chat interface in a browser using streamlit to talk to your agent, with per-user memory folders and a clean, responsive chat layout.
Fix visibility by setting the user message color to white and the agent background to black, then debug the Streamlit app in VSCode with a built-in debugger.
Save and load complete user and agent messages in the database with metadata including timestamp, role source, and user ID, ensuring persistent client connections and assembling chat history.
Improve agent specificity by converting queries to topic-based searches with a topic extraction function, updating the fetch query and parameters to yield accurate book recommendations and visit ideas.
Learn to fetch book recommendations from Google Books, include year and clickable links via a tailored template, and explore prompt engineering to shape output.
Learn how to install imports and set up an internet agent using DuckDuckGo and Lama 3.2, then run searches, manage results, and add memory for past chats.
Implement memory for an Internet agent by loading previous messages, creating memory contexts for chats and books, and supplying context to the agent so it remembers user names and hobbies.
Learn to add file upload functionality to an autonomous agent interface with Streamlit, handling pdf and text files, extracting content, and persisting file data across conversations.
Landgraf turns your AI agent into an explicit state machine by modeling decisions as a graph of nodes and edges, enabling visible reasoning, validation, and self-correction.
Build an agentic ai using Landgraf with a four-node graph—analyze, generate, validate, refine—that self-corrects via a conditional loop to answer queries, process files, and perform web searches.
What you'll learn
Build a complete AI agent from scratch using 100% open-source tools with no API costs
Understand the fundamental differences between simple chatbots and intelligent agentic AI systems
Implement web search capabilities so your agent can access real-time information from the internet
Create persistent memory systems using ChromaDB vector database for conversation history
Add file upload functionality to analyze PDFs and text documents with AI
Master the ReAct pattern (Reasoning + Acting) for intelligent decision-making
Implement chain-of-thought prompting for complex problem-solving
Build self-correction loops where agents validate and improve their own responses
Design agentic workflows using LangGraph with state machines and conditional routing
Run large language models locally using Ollama (llama3.2) with complete privacy
Create interactive chat interfaces with Streamlit for production-ready applications
Implement semantic search and vector embeddings for intelligent memory retrieval
Build autonomous agents that choose tools, plan actions, and execute tasks independently
Customize agent personality and behavior through advanced prompt engineering
Course Description
Stop paying for expensive AI APIs. Start building your own intelligent agents.
This comprehensive course teaches you how to build agentic AI systems from the ground up using modern open-source technologies. Unlike simple chatbots, agentic AI can reason, plan, use tools, remember conversations, and make autonomous decisions—all running locally on your machine with zero API costs.
What Makes This Course Different?
- 100% Open Source - No proprietary APIs, no vendor lock-in, no recurring costs
- Complete Source Code Included - Every lecture comes with fully working code you can download and customize
- Hands-On Practice Exercises - Carefully designed exercises that enhance your skills and add powerful features to your agent Production-Ready Skills - Build real applications, not toy examples.
- Local Development - Everything runs on your laptop with full data privacy
- Modern AI Stack - Learn the tools used by professional AI engineers today
What You'll Build
By the end of this course, you'll have created a fully functional agentic AI application with these capabilities:
- Web Search Integration - Agent searches DuckDuckGo for current information automatically
- Document Analysis - Upload PDFs or text files and ask questions about their content
- Persistent Memory - Conversations are remembered across sessions using vector database technology
- Intelligent Decision Making - Agent decides when to search, when to analyze files, or when to use existing knowledge
- Self-Correction - Validates its own answers and refines them if needed
- Autonomous Planning - Uses the ReAct pattern to reason before taking action
- State Management - Built with LangGraph for complex multi-step workflows
- User Sessions - Multiple users can have separate conversations with persistent history
- Customizable Personality - Change agent behavior through prompt engineering
Technologies You'll Master
AI & Machine Learning:
Ollama (Local LLM Runtime)
LangChain (Agent Framework)
LangGraph (State Machine Workflows)
llama3.2 (Open Source Language Model)
Vector Databases & Memory:
ChromaDB (Vector Database)
Embeddings and Semantic Search
Sentence Transformers
Web Development:
Streamlit (UI Framework)
Python (Programming Language)
API Integration (OpenLibrary, DuckDuckGo)
Agent Patterns:
ReAct (Reasoning + Acting)
Chain-of-Thought Prompting
Self-Correction Loops
Autonomous Decision Making
Who This Course Is For
- Python developers who want to build AI applications without expensive APIs
- Data scientists looking to add AI agent development to their skillset
- Software engineers interested in practical AI implementation
- Tech entrepreneurs building AI-powered products
- Students learning modern AI development techniques
- Professionals wanting to understand how intelligent agents work
- Anyone interested in building privacy-focused AI applications
- No prior AI experience required - we start from fundamentals and build up to advanced concepts step by step.
Prerequisites
Basic Python programming knowledge (variables, functions, loops)
Familiarity with command line/terminal
A computer with at least 8GB RAM (16GB recommended for better performance)
Willingness to learn and experiment
What Makes This Course Unique
Practice Exercises Included - Each major section includes hands-on exercises designed to deepen your understanding and add real functionality to your agent. Solutions are provided so you can verify your work.
Complete Source Code - Download working code for every single lecture. No guessing, no incomplete examples—just production-ready code you can run immediately.
Regular Updates - As AI technology evolves, this course will be updated with new techniques and tools.
From Theory to Practice - We don't just explain concepts—we build real, working applications you can deploy and customize.
Modern Best Practices - Learn the patterns and techniques used by professional AI engineers in 2024 and beyond.
Course Outcomes
By completing this course, you will:
Understand how modern AI agents work under the hood
Build production-ready agentic AI applications
Implement advanced AI patterns like ReAct and Chain-of-Thought
Master vector databases and semantic search
Create agents that can search the web, analyze files, and remember conversations
Design autonomous systems that make intelligent decisions
Save hundreds of dollars in API costs by running AI locally
Have portfolio projects to showcase your AI development skills
Join Thousands of Students Building the Future of AI
Enroll now and start building intelligent AI agents today. With our 30-day money-back guarantee, you have nothing to lose and everything to gain.
Stop using AI. Start building it.