Admission now open for 2026

Log In
Craw Security

AI programme · Python plus Generative AI

Build Real LLM Applications in a Six-Month Programme

Start with Python from scratch, then move through prompting, RAG, image generation, AI agents and secure MCP servers. Every stage ends in something you build.

Beginner friendlySix projectsSecurity-focused capstone
Need Help?
9513805401
Duration
24 weeks, 384 training hours (two months of Python plus four months of Generative AI)
Level
No prior programming or AI knowledge needed
Mode
Concept sessions, practical labs and project days

01

Who this programme is built for

The course suits students, working professionals and developers who want to understand and build with large language models. It does not assume you can code: Python is taught from the beginning during the first two months, so a complete beginner can follow.

Python developers and people who simply want to understand how LLMs and AI agents work are equally welcome. Because the capstone is a security assistant, the programme also appeals to anyone who wants AI skills with a cyber security angle.

02

Month-by-month plan

MonthFocusWhat you work on
Month 1Python FoundationSyntax, data types, loops, functions, data structures, files, errors and packaging
Month 2Python for Data and AIOOP, NumPy, Pandas, Matplotlib, APIs, CLI tools, testing, PyTorch basics
Month 3LLMs and Prompt EngineeringPrompting methods, AI tools, vector databases and local models
Month 4AI Safety, Generative Models, RAGResponsible AI, GANs, transformers, chatbots and retrieval
Month 5Multimodal and Agentic AIStable Diffusion, similarity search, building agents, a CLI coding agent
Month 6MCP, AI Security, CapstoneMCP servers, attack surface, sandboxing and the SecureAgent project

03

Projects you finish with

Six projects are included, starting small and growing in scope.

Security Log Analyzer CLI

A Python command-line tool using Pandas, argparse and pytest to analyse security logs.

Local LLM chatbot

A chatbot running on local models through Ollama and llama.cpp.

Policy-document Q&A

A retrieval-augmented question-answering system built with LangChain, FAISS and Llama-3.

SecureAgent SOC Assistant

The flagship capstone that combines RAG, agents, MCP servers, structured incident reports and guardrails.

04

Tools and libraries used

  • Python, PyTorch and Hugging Face Transformers
  • LangChain for agent workflows
  • FAISS, Milvus and ChromaDB for vector search
  • Ollama and llama.cpp for local models
  • Pydantic for structured outputs
  • FastMCP and the Claude API

05

A typical learning week

  1. 1

    Monday to Thursday

    Two hours a day of concept sessions and guided demonstrations.

  2. 2

    Saturday

    A four-hour practical lab.

  3. 3

    Sunday

    Four hours of project work, assessment and doubt clearing.

Syllabus

What you will study, module by module

Download Syllabus
01Unit 1: Python Setup and Core Syntax
  • Installing Python and configuring the development environment
  • Virtual environments and VS Code
  • Running Python scripts
  • Variables, data types, and operators
  • Strings, formatting, input, and output
  • Conditional statements and Boolean logic
  • Practical lab: Calculator and string utilities
02Unit 2: Control Flow and Functions
  • For and while loops
  • Functions, arguments, and return values
  • Scope and lambda functions
  • Introduction to recursion
  • Built-in functions and importing modules
  • Practical lab: Password strength checker
03Unit 3: Python Data Structures
  • Lists and tuples
  • Dictionaries and sets
  • Comprehensions and sorting
  • Generators
  • Collections module
  • Stack and queue concepts
  • Practical lab: Word-frequency counter and contact manager
04Unit 4: Files, Errors and Packaging
  • File handling with text and CSV files
  • JSON and pathlib
  • Exception handling
  • Logging fundamentals
  • Modules and packages
  • pip and requirements management
  • Practical lab: Log file parser
  • Python Assessment 1
05Unit 5: Object-Oriented Python
  • Classes and objects
  • Inheritance and polymorphism
  • Dunder methods and dataclasses
  • Type hints and docstrings
  • PEP 8 coding standards
  • Unit testing fundamentals
  • Practical lab: Object-oriented inventory system
06Unit 6: Data Analysis with NumPy, Pandas and Matplotlib
  • NumPy arrays
  • Vectorization and broadcasting
  • Pandas DataFrames
  • Data cleaning
  • Grouping and merging datasets
  • Data visualization with Matplotlib
  • Practical lab: Dataset analysis and visualization report
07Unit 7: Python for APIs, CLI Tools and Testing
  • HTTP and REST APIs
  • Making API requests
  • JSON responses and API keys
  • Environment variables and .env files
  • Introduction to asynchronous programming
  • Command-line tools using argparse
  • pytest and testing fundamentals
  • Git workflow
  • Practical lab: REST API client and tested CLI tool
08Unit 8: PyTorch Basics and Python Capstone
  • PyTorch tensors and operations
  • Autograd
  • Basic model training loop
  • Project design and review
  • Debugging and mentor guidance
  • Python final assessment
09Module 1: LLM Fundamentals
  • Large Language Models
  • Tokens and tokenization
  • Embeddings and semantic similarity
  • Context windows
  • Training versus inference
10Module 2: Prompt Engineering Basics
  • Prompt structure
  • Instructions and context
  • Input-output mapping
  • Good versus bad prompts
  • Output quality and prompt clarity
11Module 3: Core Prompt Engineering Techniques
  • Zero-Shot Prompting
  • Few-Shot Prompting
  • Role and instruction prompting
  • Chain-of-Thought Prompting
  • Negative Prompting
  • Structured output formatting
12Module 4: CLEAR Prompt Design Framework
  • Context
  • Length
  • Examples
  • Audience
  • Result
  • Applying CLEAR to practical AI tasks
13Module 5: Advanced Prompt Engineering
  • Prompt chaining
  • ReAct framework
  • Tree of Thoughts
  • Self-consistency
  • Prompt optimization and debugging
  • Context optimization
  • Structured outputs
14Module 6: Introduction to AI Agents
  • AI agents versus basic LLMs
  • Agent decision loops
  • Memory and tool use
  • LangChain workflows
  • Introduction to tool-enabled AI applications
15Module 7: AI Tools and Ecosystem
  • ChatGPT, Claude, and Gemini
  • Hugging Face
  • Prompt templates
  • Vector databases
  • ChromaDB and FAISS
  • APIs versus local models
16Module 8: Local AI Models
  • llama.cpp
  • Ollama
  • GGUF and quantization
  • CPU versus GPU inference
  • Running models locally
  • Offline AI applications
  • Local chatbot development
17Module 9: AI Safety and Responsible AI
  • LLM hallucinations
  • Bias auditing
  • Data privacy
  • GDPR and DPDP considerations
  • Prompt injection and jailbreak testing
  • Responsible AI practices
18Module 10: Generative AI Concepts and Models
  • Foundations of Generative AI
  • Generative model families
  • GANs, VAEs, diffusion models, and autoregressive models
  • Applications across text, images, audio, and multimodal AI
19Module 11: GANs — Generative Adversarial Networks
  • Generator and discriminator architecture
  • Adversarial training
  • Building a GAN with PyTorch
  • Image generation
  • StyleGAN and BigGAN
  • GAN-based steganography
20Module 12: Transformer Architecture
  • Input and positional embeddings
  • Layer normalization
  • Multi-Head Attention
  • Feed-forward networks
  • Transformer training and inference
  • Autoregressive decoding
21Module 13: LLM and Chatbot Development
  • Gemma 2B
  • Model deployment
  • vLLM, TGI, and Ollama
  • Conversation state and memory
  • Chatbot interfaces
22Module 14: Retrieval-Augmented Generation (RAG)
  • RAG architecture
  • Document ingestion
  • Embeddings and semantic retrieval
  • BGE and MPNet
  • FAISS indexing
  • Llama-3 integration
  • LangChain orchestration
23Module 15: Practical RAG Projects
  • PDF question-answering systems
  • Policy-document chatbots
  • LLM and vector database integration
  • Enterprise document retrieval patterns
24Module 16: Stable Diffusion and Image Generation
  • Diffusion model theory
  • Forward and reverse diffusion
  • Diffusers library
  • Text-to-image generation
  • Image-to-image generation
  • Inpainting
  • Classifier-Free Guidance (CFG)
25Module 17: Image and Text Similarity Search
  • CLIP architecture
  • Joint image-text embeddings
  • FAISS and Milvus
  • COCO dataset
  • Vector indexing and similarity search
26Module 18: Smart Video Search System
  • VILA-2.0 video understanding
  • T5 semantic descriptions
  • Video embeddings
  • Milvus vector storage
  • Video indexing and retrieval
  • Search evaluation
27Module 19: Autoencoders and Variational Autoencoders
  • Encoder, bottleneck, and decoder
  • Variational Autoencoders
  • Latent space and sampling
  • MSE and BCE loss functions
  • Image denoising
28Module 20: Introduction to AI Agents — Recap
  • AI agent architecture
  • Agent decision loops
  • LangChain workflows
  • Tool integration
29Module 21: Agentic AI Fundamentals
  • Planning and memory
  • Reflection and tool use
  • ReAct architecture
  • Plan-and-Execute
  • Multi-agent systems
  • Sandboxing and tool integration
30Module 22: Building Your First AI Agent
  • Development environment
  • Agent loop design
  • LLM and tool integration
  • Testing and debugging
  • Agent evaluation
31Module 23: Structured Outputs with Pydantic
  • Structured AI responses
  • Pydantic models
  • Output validation
  • JSON mode and function calling
  • Error handling and retry logic
32Module 24: Building a CLI Coding Agent
  • Command-line coding agent architecture
  • File read and write tools
  • Bash execution and search
  • Python-based agent loop
  • Claude API integration
  • Output validation and safety guardrails
33Module 25: MCP Fundamentals and Architecture
  • Model Context Protocol architecture
  • JSON-RPC 2.0
  • Tools, Resources, Prompts, and Sampling
  • MCP versus traditional APIs
  • MCP server architecture
34Module 26: Building MCP Servers and Tools
  • FastMCP with Python
  • TypeScript SDK
  • MCP resources and prompts
  • Sampling
  • MCP Inspector
  • Connecting MCP servers to Claude
  • Server testing and integration
35Module 27: MCP Security, Integrations and Capstone
  • MCP attack surface
  • Tool poisoning
  • Trust models
  • Sandboxing
  • Input validation and sanitization
  • Multi-server orchestration
  • Packaging and integration
  • Secure agent development

FAQ

Questions people ask before enrolling

How long is the Generative AI course?

It runs for 24 weeks and 384 training hours, made up of two months of Python and four months of Generative AI.

Can a complete beginner join?

Yes. Python is taught from scratch, so no earlier programming or AI experience is needed.

What is the fee?

A current fee is not listed on the programme page, so please ask Craw Security for the latest fee schedule, batch dates and certificate requirements.

Does it include practical work?

Yes. Sessions, demonstrations, labs, project work, assessments and a final capstone all form part of the 384-hour plan.

Is the Model Context Protocol covered?

Yes. Month six covers MCP architecture, building servers, integrations and security testing.

What job roles does this support?

It prepares you for roles such as Python developer for AI work or LLM application developer. Hiring depends on your skills and the market.

Is prompt engineering enough on its own?

Prompting is one part. The course also teaches retrieval, agents, local models and safety, because real applications need all of them.

Keep exploring

Plan your AI learning path

Speak to a counsellor about fees, the next batch and whether this course fits your background.