Description

By the end of this week, learners will build a strong foundation in Python programming for Artificial Intelligence. The focus is on Python syntax, control flow, functions, object-oriented programming, data structures, and file handling. Learners will gain practical experience by developing a command-line application that reads, processes, and transforms structured data using Python.

Topics Covered

Python Fundamentals

  1. Install and configure the Python development environment.
  2. Understand Python syntax, variables, and data types.
  3. Perform arithmetic, comparison, and logical operations.
  4. Implement decision-making using if, elif, and else statements.
  5. Use for and while loops to automate repetitive tasks.
  6. Write clean, readable, and maintainable Python code.

Functions & Object-Oriented Programming

  1. Create reusable functions with parameters and return values.
  2. Understand variable scope and function organization.
  3. Learn the fundamentals of Object-Oriented Programming (OOP).
  4. Create classes, objects, constructors, and methods.
  5. Apply inheritance and basic code reusability concepts.
  6. Organize applications using modular programming practices.

Core Data Structures

  1. Work with Lists, Tuples, Dictionaries, and Sets.
  2. Access, modify, and iterate through collections efficiently.
  3. Use list and dictionary comprehensions for concise code.
  4. Store and manipulate structured data effectively.
  5. Select appropriate data structures for different programming scenarios.
  6. Apply best practices for efficient data handling.

File Handling & JSON Processing

  1. Read from and write to text files using Python.
  2. Understand file modes and context managers.
  3. Process structured data using the JSON module.
  4. Parse, update, and generate JSON files.
  5. Handle file-related exceptions safely.
  6. Build reliable data-processing applications using Python.

Hands-on Practice

  1. Build a Command-Line Data Transformation Tool.
  2. Read structured data from a file.
  3. Process and transform the input using Python data structures.
  4. Apply functions and object-oriented programming concepts.
  5. Export the transformed data to a new file in JSON or text format.
  6. Publish the completed project to GitHub with clear documentation and usage instructions.

Learning Outcomes

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

  1. Write Python programs using industry-standard coding practices.
  2. Apply control flow, loops, and functions to solve programming problems.
  3. Build object-oriented applications using classes and objects.
  4. Manipulate data efficiently using Python's core data structures.
  5. Read, process, and write structured data using file handling and JSON.
  6. Organize Python applications using modular and reusable code.
  7. Apply software engineering best practices for AI development.
  8. Deliver a functional command-line application that reads, transforms, and exports structured data while demonstrating professional Python programming skills suitable for AI and software engineering projects.


Description

By the end of this week, learners will understand how to interact with Large Language Models using APIs and design effective prompts for reliable AI responses. The focus is on making authenticated LLM API calls, generating structured JSON outputs, validating responses safely, introducing basic tool/function calling, and applying prompt engineering fundamentals. Learners will reinforce these concepts by building a Python application that accepts user input, communicates with an LLM, and returns structured results.

Topics Covered

Making Your First LLM API Call

  1. Understand how Large Language Models are accessed through APIs.
  2. Configure API authentication using secure API keys.
  3. Store sensitive credentials using environment variables.
  4. Send prompts to Claude or OpenAI models from Python.
  5. Process structured API responses efficiently.
  6. Apply secure and maintainable API integration practices.

Prompt Engineering Fundamentals

  1. Understand the anatomy of an effective prompt.
  2. Define clear roles, tasks, context, and constraints.
  3. Write prompts that generate accurate and consistent responses.
  4. Control output formatting using explicit instructions.
  5. Reduce ambiguity through structured prompt design.
  6. Build reusable prompt templates for common AI tasks.

Structured JSON Output & Validation

  1. Generate structured JSON responses from Large Language Models.
  2. Define response schemas for predictable outputs.
  3. Parse and validate JSON responses safely.
  4. Handle malformed or incomplete JSON gracefully.
  5. Apply error handling during response processing.
  6. Build reliable AI applications using structured outputs.

Basic Tool & Function Calling

  1. Understand the concept of tool and function calling.
  2. Define simple functions with structured inputs and outputs.
  3. Enable an LLM to invoke external tools when required.
  4. Process tool execution results within Python applications.
  5. Handle tool-calling errors and fallback scenarios.
  6. Design modular AI workflows using reusable functions.

Mini Project

  1. Build a Python LLM Assistant that accepts user input.
  2. Call an LLM API using authenticated requests.
  3. Generate validated JSON responses.
  4. Integrate a basic tool/function call into the workflow.
  5. Handle common API and validation errors gracefully.
  6. Publish the completed project to GitHub with documentation and setup instructions.

Learning Outcomes

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

  1. Build Python applications that communicate with Large Language Models.
  2. Apply prompt engineering principles to generate reliable AI responses.
  3. Generate and safely validate structured JSON outputs.
  4. Implement basic tool and function calling in AI workflows.
  5. Handle API errors and invalid responses using defensive programming techniques.
  6. Design reusable prompts and modular AI application components.
  7. Apply industry-standard practices for secure and reliable AI integrations.
  8. Deliver a production-ready Python application that accepts user input, interacts with an LLM, generates validated structured output, integrates basic tool calling, and demonstrates professional AI engineering practices.


Description

By the end of this week, learners will understand how to build reliable AI applications using structured outputs and tool calling. The focus is on generating validated JSON responses, safely parsing model outputs, integrating external tools through function calling, and handling execution errors gracefully. Learners will apply these concepts by building an information extraction application that returns validated JSON from unstructured text.

Topics Covered

Structured Output with LLMs

  1. Understand the importance of structured AI responses.
  2. Generate consistent JSON output from Large Language Models.
  3. Define output schemas for predictable responses.
  4. Apply prompt techniques to enforce structured formatting.
  5. Handle optional and required response fields.
  6. Build reliable AI workflows using structured data.

JSON Parsing & Validation

  1. Parse JSON responses safely in Python.
  2. Validate outputs against predefined schemas.
  3. Handle malformed or incomplete JSON responses.
  4. Implement error handling and fallback mechanisms.
  5. Prevent application failures caused by invalid outputs.
  6. Apply defensive programming practices for AI applications.

Tool & Function Calling

  1. Understand how Large Language Models invoke external tools.
  2. Define functions with structured parameters.
  3. Execute tool calls from AI-generated requests.
  4. Process tool responses within application workflows.
  5. Handle tool execution errors gracefully.
  6. Build modular and reusable AI components.

Building Reliable AI Workflows

  1. Combine structured output with tool calling.
  2. Design multi-step AI processing pipelines.
  3. Validate inputs and outputs throughout the workflow.
  4. Improve application reliability and maintainability.
  5. Log execution results for debugging.
  6. Follow production-ready AI engineering best practices.

Hands-on Practice

  1. Build an AI Information Extractor.
  2. Accept unstructured text as input.
  3. Extract structured information using an LLM.
  4. Return validated JSON based on a predefined schema.
  5. Integrate a basic tool/function into the extraction workflow.
  6. Publish the completed project to GitHub with documentation and usage examples.

Learning Outcomes

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

  1. Generate structured JSON outputs from Large Language Models.
  2. Validate AI-generated responses safely before processing.
  3. Implement basic tool and function calling within AI applications.
  4. Build reliable workflows that combine structured outputs and external tools.
  5. Handle parsing, validation, and execution errors gracefully.
  6. Apply industry-standard software engineering practices for AI reliability.
  7. Develop modular, reusable, and maintainable AI applications.
  8. Deliver a production-ready information extraction application that converts unstructured text into validated JSON using structured output, tool calling, and robust error handling while demonstrating professional AI engineering practices.


Description

By the end of this week, learners will understand how Retrieval-Augmented Generation (RAG) enhances Large Language Models by providing relevant contextual information from external documents. The focus is on embeddings, vector databases, document chunking, indexing, semantic retrieval, and the retrieve-then-generate workflow. Learners will apply these concepts by building a complete RAG pipeline over their own documents using Chroma as the vector database.

Topics Covered

Understanding Embeddings

  1. Understand how text is converted into vector embeddings.
  2. Learn semantic similarity and vector representations.
  3. Compare embeddings with traditional keyword search.
  4. Generate embeddings using modern embedding models.
  5. Measure semantic similarity between documents.
  6. Identify real-world applications of embeddings in AI systems.

Vector Database Fundamentals

  1. Understand the purpose of vector databases.
  2. Explore Chroma architecture and core components.
  3. Store and manage embedding vectors efficiently.
  4. Perform semantic similarity searches.
  5. Retrieve the most relevant documents using vector search.
  6. Apply best practices for scalable vector storage.

Building a RAG Pipeline

  1. Understand the Retrieve-Augmented Generation (RAG) workflow.
  2. Load documents from multiple sources.
  3. Split documents into meaningful chunks.
  4. Generate embeddings and index document chunks.
  5. Retrieve relevant context for user queries.
  6. Generate grounded AI responses using retrieved information.

Optimizing Retrieval

  1. Select appropriate chunk sizes and overlap strategies.
  2. Improve retrieval quality using metadata.
  3. Rank and filter retrieved documents.
  4. Reduce hallucinations through contextual grounding.
  5. Optimize retrieval performance for AI applications.
  6. Build reliable and maintainable RAG workflows.

Hands-on Practice

  1. Build a complete RAG pipeline using personal documents.
  2. Load and preprocess documents for indexing.
  3. Generate embeddings and store them in Chroma.
  4. Retrieve relevant document chunks for user queries.
  5. Generate AI responses using retrieved context.
  6. Publish the completed project to GitHub with documentation, architecture diagrams, and setup instructions.

Learning Outcomes

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

  1. Explain how embeddings enable semantic search and retrieval.
  2. Generate vector embeddings from textual data.
  3. Store and retrieve embeddings using the Chroma vector database.
  4. Build complete Retrieval-Augmented Generation (RAG) pipelines.
  5. Apply document chunking and indexing techniques for efficient retrieval.
  6. Generate grounded AI responses using retrieved contextual information.
  7. Apply industry-standard practices for building scalable and reliable RAG systems.
  8. Deliver a production-ready Retrieval-Augmented Generation (RAG) application that indexes personal documents, performs semantic search with Chroma, retrieves relevant context, and generates accurate AI responses while demonstrating professional AI engineering and software development practices.


Description

By the end of this week, learners will understand how AI agents autonomously perform tasks by reasoning, selecting tools, and executing actions. The focus is on the agent execution loop, tool calling, agent workflows, and building a simple AI agent capable of completing a defined task using one or more external tools. Learners will reinforce these concepts by developing a functional AI agent in Python.

Topics Covered

Introduction to AI Agents

  1. Understand the difference between chatbots and AI agents.
  2. Learn the architecture of autonomous AI agents.
  3. Explore the Reason → Act → Observe agent loop.
  4. Understand goals, planning, and task execution.
  5. Identify real-world applications of AI agents.
  6. Follow best practices for agent-based system design.

Tool Calling for Agents

  1. Understand how agents interact with external tools.
  2. Define tools with structured inputs and outputs.
  3. Enable agents to select and execute appropriate tools.
  4. Process tool responses within agent workflows.
  5. Handle tool execution failures and retries.
  6. Design reusable and modular agent tools.

Building an Agent Workflow

  1. Create an agent capable of completing defined tasks.
  2. Manage user input and execution flow.
  3. Implement multi-step reasoning and decision making.
  4. Integrate one or more external tools.
  5. Validate agent responses before returning results.
  6. Build maintainable and production-ready agent architectures.

Agent Testing & Optimization

  1. Test agent behavior across different scenarios.
  2. Debug reasoning and tool execution issues.
  3. Improve reliability using validation and error handling.
  4. Optimize prompts for better agent performance.
  5. Log agent actions for monitoring and debugging.
  6. Apply software engineering best practices for AI agents.

Hands-on Practice

  1. Build a Task Automation AI Agent.
  2. Accept natural language instructions from users.
  3. Implement the Reason → Act → Observe workflow.
  4. Integrate one or two external tools.
  5. Complete a defined task and return structured results.
  6. Publish the completed project to GitHub with documentation and usage examples.

Learning Outcomes

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

  1. Explain the architecture and lifecycle of AI agents.
  2. Implement the Reason → Act → Observe execution loop.
  3. Build AI agents capable of using external tools.
  4. Design modular agent workflows for task automation.
  5. Handle tool execution and error recovery effectively.
  6. Optimize agent performance through testing and prompt refinement.
  7. Apply industry-standard software engineering practices for agent development.
  8. Deliver a production-ready AI agent that autonomously completes defined tasks using external tools, structured reasoning, and robust error handling while demonstrating professional AI engineering practices.


Description

By the end of this week, learners will understand how to deploy AI applications as production-ready web services. The focus is on building REST APIs with FastAPI, containerizing applications using Docker, and serving AI models through scalable, portable, and maintainable deployment workflows. Learners will apply these concepts by deploying their AI application inside a Docker container and exposing it through a FastAPI endpoint.

Topics Covered

Building APIs with FastAPI

  1. Understand the fundamentals of RESTful APIs.
  2. Create API endpoints using FastAPI.
  3. Handle HTTP requests and responses.
  4. Validate request and response data using Pydantic models.
  5. Test API endpoints using interactive documentation.
  6. Build clean and maintainable API architectures.

Containerization with Docker

  1. Understand the purpose of containerization.
  2. Install and configure Docker.
  3. Create a Dockerfile for Python applications.
  4. Build and run Docker containers.
  5. Manage application dependencies inside containers.
  6. Apply Docker best practices for AI applications.

Deploying AI Applications

  1. Connect AI models with FastAPI endpoints.
  2. Serve model predictions through REST APIs.
  3. Configure environment variables securely.
  4. Handle application errors and logging.
  5. Test deployed applications locally.
  6. Prepare applications for cloud deployment.

Deployment Best Practices

  1. Organize production-ready project structures.
  2. Improve application scalability and maintainability.
  3. Optimize Docker images for efficient deployment.
  4. Monitor application performance and reliability.
  5. Secure API endpoints and sensitive configurations.
  6. Follow industry-standard deployment workflows.

Hands-on Practice

  1. Build a FastAPI service for an AI application.
  2. Create REST endpoints for model inference.
  3. Containerize the application using Docker.
  4. Run the API inside a Docker container.
  5. Test the deployed service locally using HTTP requests.
  6. Publish the completed project to GitHub with documentation, Docker configuration, and deployment instructions.

Learning Outcomes

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

  1. Build RESTful APIs using FastAPI.
  2. Expose AI applications through production-ready API endpoints.
  3. Containerize Python applications using Docker.
  4. Deploy AI services in isolated and portable environments.
  5. Validate API requests and responses using Pydantic.
  6. Apply secure configuration and deployment best practices.
  7. Design scalable and maintainable AI deployment architectures.
  8. Deliver a production-ready AI application deployed through FastAPI inside a Docker container, demonstrating professional software engineering, API development, and deployment practices suitable for modern AI systems.


Description

By the end of this week, learners will integrate everything learned throughout the program into a complete AI application. The focus is on combining Large Language Models, Retrieval-Augmented Generation (RAG) or an AI agent, FastAPI, and Docker to build and deploy a production-ready AI solution. Learners will apply software engineering best practices to design, develop, test, document, and deploy a real-world AI application suitable for their professional portfolio.

Topics Covered

Designing an End-to-End AI Application

  1. Define project requirements and architecture.
  2. Design the overall AI application workflow.
  3. Select appropriate LLM, RAG, or agent architecture.
  4. Organize the project using modular components.
  5. Implement clean and maintainable code structure.
  6. Follow industry-standard software engineering practices.

Integrating AI Components

  1. Integrate Large Language Model APIs.
  2. Connect a RAG pipeline or AI agent.
  3. Implement tool calling where required.
  4. Process user requests through complete AI workflows.
  5. Validate responses and handle application errors.
  6. Optimize application performance and reliability.

Deployment & Testing

  1. Expose the application through FastAPI.
  2. Containerize the application using Docker.
  3. Test APIs and application workflows.
  4. Verify end-to-end functionality.
  5. Improve logging and error handling.
  6. Prepare the application for production deployment.

Documentation & Portfolio

  1. Create a professional GitHub repository.
  2. Write a comprehensive README with setup instructions.
  3. Document the application architecture.
  4. Record API endpoints and project features.
  5. Prepare the project for demonstrations.
  6. Build a portfolio-ready AI engineering project.

Capstone Project

  1. Build and deploy a complete AI-powered application.
  2. Integrate LLM calls with a RAG pipeline or a simple AI agent.
  3. Serve the application using FastAPI.
  4. Containerize the project using Docker.
  5. Deploy and test the application end-to-end.
  6. Publish the completed project to GitHub with documentation, deployment instructions, and a professional project showcase.

Learning Outcomes

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

  1. Design complete end-to-end AI application architectures.
  2. Integrate Large Language Models with RAG pipelines or AI agents.
  3. Build modular, scalable, and maintainable AI applications.
  4. Deploy AI services using FastAPI and Docker.
  5. Test, debug, and optimize production-ready AI workflows.
  6. Document projects following professional software engineering standards.
  7. Create portfolio-quality AI applications suitable for real-world deployment.
  8. Deliver a fully deployed AI-powered application that combines LLM capabilities with Retrieval-Augmented Generation or an AI agent, exposes REST APIs through FastAPI, runs inside Docker, and demonstrates professional AI engineering, deployment, and software development practices.


Please enroll in the Program to see calendar.

Please enroll in the Program to see recordings.