Description

By the end of this week, learners will establish a strong foundation in Python programming and the essential development tools used in modern AI and software development. The focus is on setting up the development environment, learning Git and GitHub workflows, understanding Python fundamentals, working with core data structures, object-oriented programming, and processing JSON files. Learners will apply these concepts by building a command-line application that reads and transforms JSON data before publishing it to GitHub.

Topics Covered

Python Development Environment & Git

  1. Install Python 3.x and configure the development environment.
  2. Set up Visual Studio Code with essential Python extensions.
  3. Understand the integrated terminal and Python execution workflow.
  4. Learn Git fundamentals including repository initialization and version control.
  5. Work with GitHub repositories, commits, branches, and pushes.
  6. Follow industry-standard development and source control practices.

Python Programming Fundamentals

  1. Understand Python syntax, variables, and data types.
  2. Perform type conversion and use arithmetic, comparison, and logical operators.
  3. Implement decision-making using if, elif, and else statements.
  4. Create loops using for and while for repetitive tasks.
  5. Write reusable functions with parameters and return values.
  6. Develop clean, readable, and maintainable Python programs.

Core Data Structures

  1. Work with Lists and Dictionaries for efficient data management.
  2. Create and manipulate nested data structures.
  3. Use list and dictionary comprehensions for concise data processing.
  4. Iterate, filter, and transform collections efficiently.
  5. Choose the appropriate data structure for different programming scenarios.
  6. Apply best practices for writing optimized Python code.

Object-Oriented Programming & File Handling

  1. Understand the fundamentals of Object-Oriented Programming (OOP).
  2. Create classes, objects, constructors, and instance methods.
  3. Read from and write to files using Python.
  4. Process structured data using the built-in JSON module.
  5. Handle common file and data processing exceptions.
  6. Organize applications using modular and reusable code.

Hands-on Practice

  1. Build a Command-Line JSON Processing Tool.
  2. Read structured data from a JSON file.
  3. Transform and manipulate the data using Python collections and comprehensions.
  4. Apply functions and object-oriented programming concepts.
  5. Save the transformed output to a new JSON file with proper error handling.
  6. Publish the completed project to GitHub following professional version control practices.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Configure a professional Python development environment.
  2. Use Git and GitHub for version control and project management.
  3. Write Python programs using variables, control flow, loops, and functions.
  4. Work efficiently with lists, dictionaries, and comprehensions.
  5. Build object-oriented applications using classes and objects.
  6. Read, write, and transform JSON data using Python.
  7. Apply clean coding and software engineering best practices.
  8. Deliver a functional command-line application that processes JSON files and demonstrates professional Python development and GitHub workflow skills.


Description

By the end of this week, learners will understand how to collect, clean, transform, and analyze data using Python's essential data science libraries. The focus is on working with NumPy arrays, Pandas DataFrames, data preprocessing techniques, and exploratory data analysis (EDA). Learners will apply these concepts by cleaning and analyzing a real-world CSV dataset from start to finish.

Topics Covered

NumPy Fundamentals

  1. Understand the role of NumPy in AI and data science workflows.
  2. Create and manipulate one-dimensional and multi-dimensional arrays.
  3. Perform indexing, slicing, and reshaping operations.
  4. Apply vectorized mathematical operations for efficient computation.
  5. Use broadcasting for element-wise array operations.
  6. Write optimized numerical code using NumPy best practices.

Working with Pandas DataFrames

  1. Create and manage Series and DataFrames.
  2. Import datasets from CSV and other structured file formats.
  3. Explore dataset structure, columns, and data types.
  4. Select, modify, and organize tabular data efficiently.
  5. Perform sorting, filtering, and column transformations.
  6. Build maintainable data processing pipelines using Pandas.

Data Cleaning & Exploratory Data Analysis

  1. Identify and handle missing, duplicate, and inconsistent values.
  2. Clean and preprocess datasets for AI applications.
  3. Generate descriptive statistics to understand data distributions.
  4. Group and aggregate records to discover patterns and trends.
  5. Perform basic exploratory data analysis (EDA).
  6. Apply industry-standard data preparation techniques.

Data Visualization & Insights

  1. Create quick visualizations using Pandas and Matplotlib.
  2. Generate line charts, bar charts, histograms, and scatter plots.
  3. Visualize distributions and relationships within datasets.
  4. Interpret charts to extract meaningful business insights.
  5. Present analytical findings using clear visual representations.
  6. Follow best practices for communicating data effectively.

Hands-on Practice

  1. Load a real-world CSV dataset into a Pandas DataFrame.
  2. Clean missing, duplicate, and inconsistent records.
  3. Filter, sort, and transform data using Pandas operations.
  4. Perform exploratory data analysis to identify trends and patterns.
  5. Create visualizations to summarize key findings.
  6. Document the complete workflow and publish the project to GitHub.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Manipulate numerical data efficiently using NumPy arrays.
  2. Load, organize, and transform datasets using Pandas DataFrames.
  3. Clean and preprocess real-world datasets for AI and machine learning tasks.
  4. Perform exploratory data analysis using filtering, grouping, and statistical summaries.
  5. Create meaningful visualizations using Pandas and Matplotlib.
  6. Interpret analytical results to support data-driven decision-making.
  7. Apply industry-standard data preparation and analysis workflows.
  8. Deliver a complete end-to-end data analysis project that cleans, explores, visualizes, and documents a real-world CSV dataset using professional Python data science practices.


Description

By the end of this week, learners will understand how to communicate with Large Language Models (LLMs) using REST APIs. The focus is on making authenticated API requests, securely managing API keys, understanding the structure of LLM requests, and handling responses and errors. Learners will apply these concepts by building a Python application that accepts user input, sends it to an LLM, and displays the generated response.

Topics Covered

REST APIs & Secure Authentication

  1. Understand the fundamentals of HTTP and REST APIs.
  2. Learn how API requests and responses are structured.
  3. Configure API authentication using API keys.
  4. Store sensitive credentials securely using environment variables.
  5. Manage configuration with .env files and environment settings.
  6. Follow security best practices for AI application development.

Anatomy of an LLM API Call

  1. Understand the structure of an LLM request and response.
  2. Learn the concepts of messages, roles, and tokens.
  3. Differentiate between System, User, and Assistant messages.
  4. Select appropriate AI models for different use cases.
  5. Understand token usage and response generation.
  6. Build well-structured prompts for reliable AI interactions.

Making Your First LLM API Call

  1. Configure and authenticate requests to Claude or OpenAI APIs.
  2. Send prompts using Python HTTP clients.
  3. Process structured JSON responses returned by the model.
  4. Display AI-generated responses within Python applications.
  5. Handle API status codes and response metadata.
  6. Build reusable API request functions following clean coding practices.

Error Handling & Response Processing

  1. Handle authentication, validation, and network errors gracefully.
  2. Manage timeout and rate-limit responses.
  3. Validate user input before making API requests.
  4. Parse and process structured model responses safely.
  5. Log errors for debugging and troubleshooting.
  6. Build reliable AI integrations suitable for production environments.

Mini Project

  1. Build a Python LLM Client Application.
  2. Accept user input through a command-line interface.
  3. Send prompts to Claude or OpenAI using authenticated API requests.
  4. Process and display AI-generated responses.
  5. Implement secure API key management and robust error handling.
  6. Publish the completed project to GitHub with documentation and usage instructions.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Explain how REST APIs enable communication with Large Language Models.
  2. Securely manage API keys using environment variables.
  3. Structure LLM requests using messages, roles, and token-aware prompts.
  4. Build Python applications that interact with Claude or OpenAI APIs.
  5. Process and display AI-generated responses effectively.
  6. Handle common API errors, authentication issues, and network failures.
  7. Apply industry-standard security and software engineering practices for AI integrations.
  8. Deliver a production-ready Python application that accepts user input, communicates with a Large Language Model, and returns AI-generated responses while demonstrating secure API integration and professional development practices.


Description

By the end of this week, learners will develop an intuitive understanding of how modern AI models learn, make predictions, and process language. The focus is on the machine learning workflow, neural network fundamentals, and the core concepts behind Transformer models. Rather than emphasizing mathematical derivations, learners will build conceptual understanding and apply these ideas by exploring tokenization and embeddings using real-world examples.

Topics Covered

Machine Learning Fundamentals

  1. Understand the basic workflow of machine learning models.
  2. Learn the fit → predict → score pattern used in model development.
  3. Differentiate between training, inference, and evaluation.
  4. Understand the roles of features, labels, and datasets.
  5. Explore supervised learning through simple examples.
  6. Build a conceptual foundation for predictive AI systems.

Neural Networks (Conceptual Overview)

  1. Understand the evolution from traditional machine learning to neural networks.
  2. Learn the structure of artificial neurons and neural networks.
  3. Explore input, hidden, and output layers.
  4. Understand the purpose of activation functions such as ReLU, Sigmoid, and Softmax.
  5. Learn how neural networks improve predictions through training.
  6. Build intuition for how deep learning models recognize complex patterns.

Transformers & Large Language Models

  1. Understand why Transformer models replaced earlier sequence models.
  2. Learn how text is converted into tokens through tokenization.
  3. Explore embeddings as numerical representations of semantic meaning.
  4. Understand the intuition behind the self-attention mechanism.
  5. Learn how context helps LLMs generate coherent responses.
  6. Build a conceptual understanding of modern Large Language Models.

From Text to Meaning

  1. Understand how words are represented as vectors.
  2. Explore semantic similarity using embeddings.
  3. Learn how related words appear closer together in vector space.
  4. Compare keyword search with semantic understanding.
  5. Understand how embeddings support search, retrieval, and AI assistants.
  6. Connect Transformer concepts to real-world AI applications.

Hands-on Practice

  1. Tokenize sample text using a Transformer tokenizer.
  2. Inspect generated token IDs and token sequences.
  3. Generate embeddings for words and sentences.
  4. Compare embedding vectors to observe semantic similarity.
  5. Experiment with different text inputs and analyze contextual changes.
  6. Document findings and publish the project to GitHub following professional development practices.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Explain the fit → predict → score workflow used in machine learning.
  2. Describe the basic architecture and operation of neural networks.
  3. Understand the purpose of neurons, layers, and activation functions.
  4. Explain how Transformers process language using tokenization, embeddings, and self-attention.
  5. Interpret semantic similarity through embedding representations.
  6. Relate Transformer concepts to modern Large Language Models and AI applications.
  7. Apply conceptual AI knowledge to understand how intelligent systems process and generate language.
  8. Deliver a practical demonstration that tokenizes text, generates embeddings, and analyzes semantic similarity while demonstrating a solid conceptual understanding of modern AI model architectures.


Description

By the end of this week, learners will understand how to configure Large Language Models effectively and design prompts that consistently produce accurate, reliable, and structured responses. The focus is on controlling model behavior through inference parameters, writing well-structured prompts, and applying advanced prompting techniques such as few-shot prompting and chain-of-thought reasoning. Learners will apply these concepts by iteratively improving a weak prompt and evaluating the quality of AI-generated responses.

Topics Covered

LLM API Parameters

  1. Understand how model parameters influence AI-generated responses.
  2. Configure temperature, top-p, and max tokens effectively.
  3. Learn the purpose of stop sequences and response length limits.
  4. Balance creativity, consistency, and accuracy for different tasks.
  5. Optimize prompts for quality, latency, and cost.
  6. Apply best practices for configuring production-ready AI applications.

Prompt Anatomy

  1. Understand the components of an effective prompt.
  2. Define clear roles, tasks, context, and constraints.
  3. Structure prompts for predictable and consistent outputs.
  4. Specify response formats and output requirements.
  5. Reduce ambiguity through precise instructions.
  6. Build reusable prompt templates for common AI workflows.

Advanced Prompting Techniques

  1. Understand Zero-Shot, One-Shot, and Few-Shot Prompting.
  2. Apply Few-Shot Prompting using practical examples.
  3. Learn Chain-of-Thought prompting for complex reasoning tasks.
  4. Guide models through step-by-step problem-solving.
  5. Select the appropriate prompting strategy for different use cases.
  6. Improve response quality through structured prompt design.

Prompt Evaluation & Optimization

  1. Compare outputs from multiple prompt variations.
  2. Identify weaknesses in poorly written prompts.
  3. Refine prompts through iterative testing.
  4. Evaluate responses for accuracy, consistency, and completeness.
  5. Document prompt improvements and performance differences.
  6. Follow industry-standard prompt engineering workflows.

Hands-on Practice

  1. Analyze and improve a weak prompt through multiple iterations.
  2. Configure model parameters such as temperature, top-p, and max tokens.
  3. Apply few-shot and chain-of-thought prompting techniques.
  4. Compare AI responses before and after prompt optimization.
  5. Measure improvements in response quality, consistency, and relevance.
  6. Publish the prompt library, evaluation results, and documentation to GitHub.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Configure LLM parameters such as temperature, top-p, and max tokens effectively.
  2. Design well-structured prompts using roles, tasks, context, and constraints.
  3. Apply zero-shot, one-shot, few-shot, and chain-of-thought prompting techniques.
  4. Optimize prompts through systematic testing and refinement.
  5. Evaluate AI-generated responses using quality and consistency metrics.
  6. Build reusable prompt templates for production AI applications.
  7. Apply industry-standard prompt engineering practices to improve model performance.
  8. Deliver an optimized prompt engineering project that demonstrates measurable improvements in AI response quality through parameter tuning, structured prompting, and iterative evaluation.


Description

By the end of this week, learners will understand how to generate reliable, structured responses from Large Language Models and evaluate their quality systematically. The focus is on enforcing structured JSON outputs, validating AI-generated data, introducing tool/function calling, and building lightweight evaluation workflows using LLM-as-a-judge techniques. Learners will apply these concepts by developing a prompt-powered application that produces validated structured output and measures response quality through an evaluation harness.

Topics Covered

Structured JSON Output

  1. Understand the importance of structured outputs in AI applications.
  2. Generate consistent JSON responses using prompt engineering.
  3. Define schemas for predictable AI-generated data.
  4. Parse structured responses safely within Python applications.
  5. Handle malformed or incomplete JSON outputs gracefully.
  6. Follow best practices for reliable structured AI workflows.

JSON Validation & Safe Processing

  1. Validate AI-generated JSON against predefined schemas.
  2. Handle validation failures and parsing exceptions.
  3. Sanitize and verify structured responses before processing.
  4. Implement fallback strategies for invalid outputs.
  5. Build robust data processing pipelines using validated responses.
  6. Apply defensive programming techniques for production AI systems.

Tool & Function Calling Basics

  1. Understand the concept of tool and function calling in modern LLMs.
  2. Define functions with structured input and output schemas.
  3. Learn how models decide when to invoke external tools.
  4. Process tool execution requests and returned results.
  5. Integrate simple external functions into AI workflows.
  6. Build modular AI applications using tool-calling patterns.

LLM Evaluation Fundamentals

  1. Create a lightweight evaluation dataset for testing prompts.
  2. Understand the concept of LLM-as-a-Judge evaluation.
  3. Score outputs based on accuracy, relevance, and completeness.
  4. Compare prompt variations using consistent evaluation criteria.
  5. Record evaluation metrics and identify areas for improvement.
  6. Establish repeatable workflows for AI quality assessment.

Mini Project

  1. Build a Prompt-Powered Structured Output Application.
  2. Generate validated JSON responses from an LLM.
  3. Integrate basic tool/function calling into the application.
  4. Create a small evaluation dataset with multiple test cases.
  5. Score responses using an LLM-as-a-Judge evaluation workflow.
  6. Publish the complete project, evaluation results, and documentation to GitHub.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Generate reliable structured JSON responses from Large Language Models.
  2. Validate and safely process AI-generated structured data.
  3. Implement basic tool and function calling in AI applications.
  4. Build reusable workflows that integrate structured outputs with external functions.
  5. Design lightweight evaluation datasets for prompt testing.
  6. Evaluate AI responses using LLM-as-a-Judge scoring techniques.
  7. Apply industry-standard practices for reliability, validation, and quality assurance in AI systems.
  8. Deliver a production-ready prompt-powered application that generates validated structured output, integrates tool calling, and includes an automated evaluation harness for measuring AI response quality.


Description

By the end of this week, learners will understand how Large Language Models represent text as numerical vectors and how vector databases enable semantic search. The focus is on embeddings, similarity metrics, vector indexing, and working with modern vector databases such as Chroma and pgvector. Learners will apply these concepts by embedding a collection of documents and building a semantic search application capable of retrieving relevant information based on meaning rather than keywords.

Topics Covered

Understanding Embeddings

  1. Understand how text is converted into vector embeddings.
  2. Learn why embeddings capture semantic meaning instead of exact keywords.
  3. Explore sentence and document embeddings.
  4. Compare lexical search with semantic search.
  5. Understand embedding models and their common applications.
  6. Build intuition for vector representations used in modern AI systems.

Similarity Metrics

  1. Understand the concept of vector similarity.
  2. Learn how Cosine Similarity measures semantic closeness.
  3. Compare cosine similarity with Euclidean distance and dot product.
  4. Rank documents based on similarity scores.
  5. Interpret similarity values for search and retrieval tasks.
  6. Apply best practices for embedding-based retrieval systems.

Vector Databases

  1. Understand the role of vector databases in AI applications.
  2. Learn how vector indexing improves retrieval performance.
  3. Explore Chroma for lightweight local vector storage.
  4. Understand pgvector for PostgreSQL-based vector search.
  5. Store, update, and retrieve embeddings efficiently.
  6. Build scalable retrieval systems using vector databases.

Semantic Search Workflow

  1. Convert documents into embeddings using an embedding model.
  2. Store embeddings and metadata in a vector database.
  3. Generate embeddings for user queries.
  4. Perform semantic search using similarity matching.
  5. Retrieve the most relevant documents based on meaning.
  6. Understand how embeddings power Retrieval-Augmented Generation (RAG) systems.

Hands-on Practice

  1. Build a document embedding pipeline using Python.
  2. Generate embeddings for a collection of real-world documents.
  3. Store embeddings in Chroma or pgvector.
  4. Implement semantic search using similarity queries.
  5. Compare semantic search results with traditional keyword search.
  6. Publish the completed project to GitHub with documentation and sample queries.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Explain how embeddings represent the semantic meaning of text.
  2. Generate embeddings for documents and user queries.
  3. Apply similarity metrics to compare vector representations.
  4. Store and manage embeddings using Chroma or pgvector.
  5. Build semantic search applications powered by vector databases.
  6. Retrieve relevant information using meaning-based search instead of keyword matching.
  7. Apply industry-standard retrieval workflows used in modern AI and RAG applications.
  8. Deliver a production-ready semantic search application that embeds documents, stores vectors in a database, and retrieves relevant content using embedding similarity and professional AI engineering practices.


Description

By the end of this week, learners will understand how Retrieval-Augmented Generation (RAG) combines document retrieval with Large Language Models to generate accurate, grounded responses. The focus is on document loading, chunking, embedding generation, vector indexing, top-k retrieval, and synthesizing answers with citations. Learners will apply these concepts by building a complete RAG pipeline over their own document collection.

Topics Covered

Introduction to Retrieval-Augmented Generation (RAG)

  1. Understand the architecture and workflow of a RAG system.
  2. Learn how retrieval improves the accuracy of LLM responses.
  3. Explore the components of a modern RAG pipeline.
  4. Differentiate between traditional LLM prompting and retrieval-based generation.
  5. Understand common RAG use cases in enterprise AI applications.
  6. Apply best practices for designing scalable retrieval systems.

Document Loading & Chunking

  1. Load documents from PDF, text, Markdown, and web sources.
  2. Preprocess documents for efficient indexing.
  3. Split documents into meaningful chunks.
  4. Understand chunk size and chunk overlap strategies.
  5. Preserve metadata during document processing.
  6. Optimize chunking for retrieval quality and LLM context windows.

Embedding, Indexing & Retrieval

  1. Generate embeddings for document chunks.
  2. Store embeddings in a vector database.
  3. Build searchable vector indexes using Chroma or pgvector.
  4. Execute semantic search using top-k retrieval.
  5. Rank retrieved documents based on relevance.
  6. Optimize retrieval performance for accuracy and speed.

Grounded Answer Generation

  1. Pass retrieved context to an LLM for response generation.
  2. Generate grounded answers using retrieved knowledge.
  3. Include source citations with generated responses.
  4. Reduce hallucinations through retrieval-based prompting.
  5. Handle missing or low-confidence retrieval results gracefully.
  6. Build reliable AI assistants using RAG best practices.

Hands-on Practice

  1. Build a complete Retrieval-Augmented Generation (RAG) pipeline.
  2. Load and preprocess a personal document collection.
  3. Generate embeddings and index documents in a vector database.
  4. Implement semantic retrieval using top-k search.
  5. Generate grounded answers with citations using an LLM.
  6. Publish the completed RAG application to GitHub with documentation and sample queries.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Explain the architecture and workflow of Retrieval-Augmented Generation (RAG).
  2. Load, preprocess, and chunk documents for semantic retrieval.
  3. Generate embeddings and index documents in a vector database.
  4. Retrieve relevant information using top-k semantic search.
  5. Generate grounded AI responses using retrieved context and citations.
  6. Reduce hallucinations through retrieval-based prompting techniques.
  7. Apply industry-standard practices for building scalable and reliable RAG applications.
  8. Deliver a production-ready Retrieval-Augmented Generation system that indexes personal documents, performs semantic search, and generates citation-backed responses using modern AI engineering best practices.


Description

By the end of this week, learners will understand how to evaluate and optimize Retrieval-Augmented Generation (RAG) systems for accuracy, relevance, and reliability. The focus is on hybrid search, reranking techniques, retrieval and answer quality metrics, and strategies for reducing hallucinations. Learners will apply these concepts by building an enhanced RAG assistant with citations and a measurable evaluation framework.

Topics Covered

Hybrid Search Fundamentals

  1. Understand the limitations of semantic-only retrieval.
  2. Learn the principles of hybrid search combining keyword and vector search.
  3. Explore lexical search using BM25 alongside semantic retrieval.
  4. Compare hybrid retrieval with embedding-only search.
  5. Optimize search quality for diverse query types.
  6. Apply industry-standard retrieval strategies for enterprise AI systems.

Reranking & Retrieval Optimization

  1. Understand the purpose of reranking in RAG pipelines.
  2. Learn how reranking improves retrieval relevance.
  3. Compare initial retrieval results with reranked outputs.
  4. Optimize top-k retrieval for improved answer quality.
  5. Apply metadata filtering and query refinement techniques.
  6. Build efficient retrieval pipelines with higher precision.

Evaluating Retrieval & Answer Quality

  1. Understand key retrieval metrics such as Recall@K, Precision, and Hit Rate.
  2. Evaluate answer quality based on relevance, completeness, and factual accuracy.
  3. Measure groundedness using retrieved document citations.
  4. Compare multiple retrieval configurations objectively.
  5. Record evaluation results using a lightweight benchmark dataset.
  6. Establish repeatable evaluation workflows for production AI systems.

Reducing Hallucinations

  1. Identify common causes of hallucinations in RAG applications.
  2. Improve prompt design using retrieved context effectively.
  3. Limit responses to retrieved evidence only.
  4. Handle insufficient or missing context gracefully.
  5. Strengthen citation-based answer generation.
  6. Apply best practices for building trustworthy AI assistants.

Project

  1. Enhance an existing Retrieval-Augmented Generation (RAG) application.
  2. Implement hybrid search with semantic and keyword retrieval.
  3. Integrate reranking to improve document relevance.
  4. Evaluate retrieval and answer quality using predefined metrics.
  5. Generate grounded responses with accurate source citations.
  6. Publish the complete evaluated RAG assistant to GitHub with documentation and performance reports.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Explain the role of hybrid search and reranking in Retrieval-Augmented Generation systems.
  2. Optimize document retrieval using semantic and keyword-based search techniques.
  3. Evaluate retrieval quality using Recall@K, Precision, and Hit Rate metrics.
  4. Measure answer quality through groundedness, relevance, and factual accuracy.
  5. Reduce hallucinations by improving retrieval, prompting, and citation workflows.
  6. Build reliable and trustworthy RAG applications using industry-standard evaluation practices.
  7. Analyze system performance and identify opportunities for continuous improvement.
  8. Deliver a production-ready RAG assistant that combines hybrid search, reranking, citation-based responses, and a comprehensive evaluation framework demonstrating professional AI engineering practices.


Description

By the end of this week, learners will understand how AI agents extend Large Language Models by reasoning, using tools, and executing multi-step workflows autonomously. The focus is on the agent execution loop, tool calling, custom tool development, and building intelligent workflows using modern agent frameworks such as Claude Agent SDK or LangGraph. Learners will apply these concepts by building an AI agent that uses multiple custom tools to complete a real-world task.

Topics Covered

Understanding AI Agents

  1. Understand the difference between LLMs, workflows, and AI agents.
  2. Learn the Reason → Act → Observe execution loop.
  3. Explore how agents plan and execute multi-step tasks.
  4. Understand agent memory, state, and iterative reasoning.
  5. Identify suitable use cases for autonomous AI agents.
  6. Apply best practices for designing reliable agent workflows.

Tool Calling Fundamentals

  1. Understand how Large Language Models interact with external tools.
  2. Learn the lifecycle of tool invocation and execution.
  3. Define structured input and output schemas for tools.
  4. Process tool requests and return results to the agent.
  5. Handle tool execution failures and fallback strategies.
  6. Build modular AI systems using reusable tool interfaces.

Building Agents with Modern Frameworks

  1. Explore Claude Agent SDK and LangGraph architectures.
  2. Configure an agent with custom tools and execution logic.
  3. Design multi-step workflows using reasoning and tool selection.
  4. Maintain conversation state across multiple actions.
  5. Log and monitor agent execution for debugging.
  6. Build scalable and maintainable agent-based applications.

Custom Tools & Agent Workflows

  1. Design custom tools for practical automation tasks.
  2. Connect APIs, local functions, and external services as tools.
  3. Chain multiple tools together to solve complex problems.
  4. Validate tool outputs before continuing execution.
  5. Optimize agent workflows for efficiency and reliability.
  6. Follow production-ready software engineering practices for agent development.

Hands-on Practice

  1. Build an AI agent using Claude Agent SDK or LangGraph.
  2. Create 2–3 custom tools for real-world automation.
  3. Implement the Reason → Act → Observe execution loop.
  4. Enable the agent to select and invoke tools dynamically.
  5. Test the agent across multiple real-world scenarios and edge cases.
  6. Publish the completed project to GitHub with architecture documentation and usage examples.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Explain the architecture and workflow of modern AI agents.
  2. Describe the Reason → Act → Observe execution model.
  3. Build custom tools that integrate with Large Language Models.
  4. Develop AI agents using Claude Agent SDK or LangGraph.
  5. Design multi-step workflows that combine reasoning with tool execution.
  6. Debug, monitor, and improve agent behavior using structured workflows.
  7. Apply industry-standard practices for building scalable, reliable, and maintainable AI agents.
  8. Deliver a production-ready AI agent that autonomously completes tasks by reasoning, selecting, and executing multiple custom tools while demonstrating professional AI engineering and software development practices.


Description

By the end of this week, learners will understand how to extend AI applications using the Model Context Protocol (MCP), accelerate development with Claude Code, and deploy AI applications as production-ready services using FastAPI and Docker. The focus is on connecting AI agents to external tools through MCP, leveraging agentic coding workflows, and containerizing applications for consistent deployment. Learners will apply these concepts by serving their AI application through a FastAPI API running inside a Docker container.

Topics Covered

Model Context Protocol (MCP) Essentials

  1. Understand the purpose and architecture of the Model Context Protocol (MCP).
  2. Learn how MCP enables AI models to access external tools and resources.
  3. Explore MCP servers, clients, tools, and resources.
  4. Connect an AI application to an MCP server.
  5. Configure and test MCP-based integrations.
  6. Apply best practices for secure and scalable MCP implementations.

Claude Code for Agentic Development

  1. Understand the capabilities of Claude Code for AI-assisted software development.
  2. Learn agentic coding workflows for building and maintaining applications.
  3. Generate, modify, and review code using Claude Code.
  4. Automate development tasks such as debugging and refactoring.
  5. Improve productivity with AI-assisted coding practices.
  6. Follow professional software engineering workflows with AI pair programming.

Building Production APIs with FastAPI

  1. Understand FastAPI architecture and request handling.
  2. Create RESTful API endpoints for AI applications.
  3. Accept user input and return AI-generated responses.
  4. Implement request validation and structured JSON responses.
  5. Configure environment variables and application settings.
  6. Build scalable backend services using FastAPI best practices.

Containerization with Docker

  1. Understand the fundamentals of Docker containers.
  2. Create a Dockerfile for packaging AI applications.
  3. Manage dependencies and runtime environments.
  4. Build and run Docker images locally.
  5. Configure environment variables inside containers.
  6. Prepare AI applications for cloud and production deployment.

Hands-on Practice

  1. Connect an AI application to an MCP server.
  2. Use Claude Code to enhance and maintain the application.
  3. Wrap the application with a FastAPI backend.
  4. Create and configure a Docker container for deployment.
  5. Run and test the API locally inside Docker.
  6. Publish the complete project to GitHub with deployment documentation and setup instructions.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Explain the architecture and purpose of the Model Context Protocol (MCP).
  2. Connect AI applications to external tools using an MCP server.
  3. Use Claude Code to accelerate software development and agentic coding workflows.
  4. Develop production-ready REST APIs using FastAPI.
  5. Containerize AI applications using Docker for consistent deployment.
  6. Configure and deploy AI services following modern DevOps practices.
  7. Apply industry-standard software engineering techniques for scalable AI application deployment.
  8. Deliver a production-ready AI application that integrates MCP, leverages Claude Code, exposes REST APIs through FastAPI, and runs reliably inside a Docker container suitable for deployment in modern cloud environments.


Description

By the end of this week, learners will integrate everything learned throughout the program into a complete, production-ready AI application. The focus is on combining Retrieval-Augmented Generation (RAG), AI agents, tool calling, deployment, safety mechanisms, monitoring, and professional documentation. Learners will deliver a polished portfolio project that demonstrates industry-standard AI engineering skills from development to deployment.

Topics Covered

End-to-End AI Application Development

  1. Design the architecture of a complete AI application.
  2. Combine RAG, AI agents, and external tools into a unified workflow.
  3. Build an intuitive user interface for interacting with the application.
  4. Integrate backend services with LLM-powered features.
  5. Manage application configuration and environment variables.
  6. Follow clean architecture and modular software engineering principles.

Safety & Reliability

  1. Implement basic input and output safety filtering.
  2. Validate user requests before processing.
  3. Reduce hallucinations using grounded retrieval and tool validation.
  4. Handle application errors and unexpected failures gracefully.
  5. Log important events for debugging and monitoring.
  6. Apply responsible AI and production reliability best practices.

Deployment & Production Readiness

  1. Deploy the AI application to a cloud-ready environment.
  2. Configure production settings and environment secrets.
  3. Verify API endpoints and application health.
  4. Test end-to-end workflows after deployment.
  5. Optimize application performance and reliability.
  6. Prepare the project for public demonstration and portfolio use.

Documentation & Portfolio

  1. Create a professional GitHub README with setup instructions.
  2. Document project architecture and implementation details.
  3. Prepare a demonstration video or live walkthrough.
  4. Showcase features, technologies, and engineering decisions.
  5. Create a portfolio-ready project entry with screenshots.
  6. Present the application following professional software development standards.

Capstone Project

  1. Build and deploy a complete AI-powered application.
  2. Integrate RAG and/or an intelligent AI agent with custom tools.
  3. Implement safety filtering, monitoring, and structured logging.
  4. Deploy the application with a production-ready interface.
  5. Create complete documentation and portfolio assets.
  6. Publish the finished project to GitHub with deployment links and a live demonstration.

Learning Outcomes

By the end of this week, learners will be able to:

  1. Design and develop a complete end-to-end AI application.
  2. Integrate Retrieval-Augmented Generation (RAG), AI agents, and external tools into a single workflow.
  3. Implement basic AI safety, monitoring, and reliability mechanisms.
  4. Deploy production-ready AI applications with modern software engineering practices.
  5. Create professional project documentation and GitHub repositories.
  6. Present AI projects effectively for interviews and professional portfolios.
  7. Demonstrate proficiency in the complete AI application development lifecycle, from architecture to deployment.
  8. Deliver a production-ready, deployed AI application that combines RAG and/or AI agents, utilizes external tools, incorporates safety and monitoring features, and serves as a


Please enroll in the Program to see calendar.

Please enroll in the Program to see recordings.