Agentic AI for Technical Professionals
Building Practical AI Agent Systems for professional deplyment - 2 days
Agentic AI is becoming one of the most important areas in modern software engineering, infrastructure automation, enterprise platforms, and intelligent operations. Organizations are rapidly moving beyond simple chatbot implementations toward autonomous and semi-autonomous systems capable of planning, tool usage, workflow orchestration, reasoning, event processing, and multi-agent collaboration. Technical professionals are increasingly expected to understand how these systems are designed, deployed, governed, and integrated into real production environments.
This course focuses on the practical implementation of Agentic AI systems using Python on Linux environments. Participants will work with modern architectural approaches including simple agent pipelines, multi-agent orchestration, Kafka-based distributed workflows, cloud-hosted LLM APIs, on-premise SLM and LLM deployments, quantization techniques, Human-in-the-Loop workflows, and MCP-based interoperability patterns. The delivery emphasizes real engineering workflows and operational practices rather than purely theoretical or academic discussions.
The course is delivered by an instructor with over 30 years of industry experience using practical, industry-driven implementation approaches aligned with current enterprise adoption patterns and operational requirements.
Learning Outcomes
- Understand Agentic AI architecture and workflows
- Build simple agentic pipelines using Python
- Design multi-agent orchestration systems
- Implement Kafka-based distributed agent workflows
- Deploy and operate on-premise SLMs and LLMs
- Understand and apply quantization techniques
- Integrate cloud-hosted LLM APIs into agent systems
- Implement Human-in-the-Loop workflows
- Understand MCP architecture and interoperability
- Build Linux-based AI development environments
- Apply operational, security, and governance best practices
- Design scalable enterprise agentic systems
Prerequisites
- Basic Python programming knowledge
- Familiarity with Linux command-line operations
- Basic API knowledge
- Basic networking concepts
- General software development experience
- Familiarity with JSON and YAML
Training Outline
- Introduction to Agentic AI
- Agentic AI concepts
- Autonomous workflows
- Agents versus traditional AI systems
- Agent lifecycle
- Planning and reasoning
- Tool usage
- Context management
- Agent memory concepts
- Enterprise use cases
- Current industry trends
- Professional Environment Preparation
- Python installation
- Virtual environments
- Package management
- GPU considerations
- CUDA overview
- Linux AI tooling
- IDE and editor setup
- Environment configuration
- Logging setup
- Project structures
- Python Foundations for Agentic AI
- API integration
- REST workflows
- JSON handling
- Async processing
- Event-driven programming
- Error handling
- Retry logic
- Configuration management
- Secrets management
- Creating a Simple Agentic Pipeline
- Agent loop creation
- Prompt handling
- Tool registration
- Tool invocation
- Function calling
- Context management
- State management
- Response handling
- Structured outputs
- Error handling
- Retry workflows
- Logging and tracing
- Working with Cloud LLM APIs
- Cloud LLM providers
- API authentication
- API request handling
- Streaming responses
- Function calling APIs
- Context window management
- Multi-model workflows
- Rate limiting
- Token management
- Cost considerations
- Security considerations
- Human-in-the-Loop (HITL)
- HITL concepts
- Approval workflows
- Manual intervention models
- Escalation workflows
- Human review pipelines
- Workflow interruption handling
- Confidence scoring
- Governance considerations
- Audit logging
- Operational controls
- Multi-Agent Systems
- Multi-agent architecture
- Agent orchestration
- Planner-executor patterns
- Hierarchical agents
- Shared memory approaches
- Agent communication
- Event-driven workflows
- Distributed orchestration
- Workflow coordination
- Failure handling
- Creating Multi-Agent Pipelines with Microservices and Kafka
- Microservices architecture
- Service decomposition
- Stateless services
- API gateway concepts
- Kafka fundamentals
- Topics and partitions
- Producers and consumers
- Event streaming
- Message serialization
- Python Kafka integration
- Agent-to-agent messaging
- Distributed task execution
- Event choreography
- Retry patterns
- Dead-letter queues
- Workflow resiliency
- Observability and tracing
- On-Premise SLM and LLM Deployment
- SLM concepts
- LLM concepts
- Model selection
- CPU versus GPU deployment
- Local inference
- Model serving
- Linux deployment considerations
- Containerized deployment
- Resource management
- Performance considerations
- Security considerations
- Air-gapped deployments
- Quantization
- Quantization fundamentals
- FP16
- INT8
- INT4
- GPTQ
- AWQ
- GGUF
- Dynamic quantization
- Static quantization
- Memory optimization
- CPU optimization
- GPU optimization
- Accuracy trade-offs
- Benchmarking
- Deployment considerations
- Model Context Protocol (MCP)
- MCP concepts
- MCP architecture
- MCP clients
- MCP servers
- Tool interoperability
- Context exchange
- Session handling
- Tool registration
- Python integration
- MCP service design
- Security considerations
- Governance considerations
- Security and Governance
- Prompt injection risks
- Unauthorized tool execution
- Context poisoning
- Credential management
- Sandboxed execution
- Access controls
- Policy enforcement
- Secure API integration
- Auditability
- Observability
- Compliance considerations
- Operational governance
- Monitoring and Operational Reliability
- Logging
- Distributed tracing
- Agent telemetry
- Workflow monitoring
- Failure handling
- Retry workflows
- Recovery strategies
- Performance monitoring
- Scalability considerations
- Operational best practices
- Capstone Architecture Walkthrough
- Single-agent architecture
- Multi-agent architecture
- Kafka orchestration workflows
- HITL integration
- MCP interoperability
- Hybrid cloud and on-prem models
- Quantized inference deployment
- Operational architecture patterns
Disclaimer
This training outline is intended solely as a general guideline for course delivery. The trainer reserves the right to modify, reorganize, expand, reduce, or amend the content, technologies, tooling, sequence of topics, demonstrations, and technical depth based on participant requirements, operational considerations, software updates, infrastructure availability, and evolving industry practices without prior notice.
Practical, connected learning
My wider training approach brings hands-on implementation and systems thinking together, connecting technology with real operational needs.