AI for developers
Python and AI engineer: code with assistants, then build LLM applications
Ten days to code with AI assistants, then design, evaluate and deploy applications based on LLMs, RAG and agents.
- Duration
- 70 h · 10 days
- Level
- Advanced
- Format
- On site · Remote · Blended
- Max. group size
- 12 participants
Overview
This ten-day path moves a Python developer toward AI engineering. The first five days cover assisted development: code assistants in the IDE, generation, refactoring, testing, documentation, debugging and security of the code produced. The next five cover building applications: model API calls, LLM frameworks, RAG, agents and multi-agent systems, evaluation and security, deployment and optimization, then a capstone project and a sustainable AI approach.
Who this program is for
- Working Python developers
- Software engineers who want to integrate LLMs into their products
- Technical teams building an AI engineering practice
Prerequisites
- Hands-on Python development experience (functions, classes, modules, dependencies)
- Comfortable with a development environment and Git
- No prior knowledge of AI required
- Notions of REST APIs appreciated
Learning objectives
- Use code assistants to speed up development
- Generate, refactor, test, document and debug Python code with AI
- Secure the code produced with the help of AI
- Integrate language models into Python applications
- Design LLM applications, RAG architectures and agents
- Evaluate, secure, deploy and optimize LLM-based applications
- Adopt a compliant and sustainable AI engineering approach
Detailed curriculum
20 modules · 70 h · 10 days
Day 1
Generative AI and the agentic approach
50% theory · 50% practice
- Language models: principles, strengths and limits
- Agents and uses in development
- Overview of tools and models
- Usage framework and privacy
- Scoping the capstone project
Prompt engineering applied to code
30% theory · 70% practice
- Writing a useful request for a code assistant
- Providing the right context
- Iterating and correcting
- Common pitfalls
- Team prompt library
🛠 Hands-on workshops
Code prompts workshop1.5 h
Test different phrasings on development tasks.
✅ Deliverable : A prompt library
Day 2
Code assistants in the IDE
50% theory · 50% practice
- Completion, chat and agent mode
- Comparing several assistants
- Configuring project instructions and rules
- Managing context and files
- Working shortcuts
Code generation and understanding
30% theory · 70% practice
- Generating functions and modules
- Exploring unfamiliar code
- Writing small applications
- Reviewing and validating what is generated
- Limits and warning signs
🛠 Hands-on workshops
Take over an existing project2 h
Understand and extend an unfamiliar codebase with AI.
✅ Deliverable : A feature added
Day 3
Refactoring and modernization
50% theory · 50% practice
- Spotting code to improve
- Refactoring in safe steps
- Migrating versions and libraries
- Typing and readability
- Keeping control of the change
Testing with pytest assisted by AI
30% theory · 70% practice
- Generating unit tests
- Edge cases and datasets
- Mocks and fixtures
- Measuring coverage
- Assessing the quality of generated tests
🛠 Hands-on workshops
Safety net2 h
Build a test suite for a legacy module.
✅ Deliverable : A pytest suite
Day 4
Assisted documentation and debugging
50% theory · 50% practice
- Generating and maintaining documentation
- Docstrings and user guides
- Diagnosing an error with AI
- Logs and minimal reproductions
- Assisted code review
Security of generated code
30% theory · 70% practice
- Common vulnerabilities in generated code
- Dependencies and the supply chain
- Secrets and sensitive data
- Static analysis and security review
- Team usage policy
🛠 Hands-on workshops
Audit of generated code1.5 h
Spot and fix flaws in code produced by an AI.
✅ Deliverable : An audit report
Day 5
Model API calls
50% theory · 50% practice
- Principles of an LLM API
- Messages, system instructions and parameters
- Structured outputs
- Handling errors, limits and costs
- First Python client
Industrializing prompting
30% theory · 70% practice
- Versioned prompt templates
- Separating prompts, code and configuration
- Prompt test sets
- Call logging
- Cache and reuse
🛠 Hands-on workshops
Model call layer2 h
Write a reusable abstraction layer.
✅ Deliverable : A model access module
Day 6
LLM frameworks
50% theory · 50% practice
- Role of frameworks and alternatives
- LangChain: components and chains
- LlamaIndex: data and indexes
- Choosing a framework or not using one
- Observability
RAG architecture
30% theory · 70% practice
- Principle of retrieval-augmented generation
- Chunking and embeddings
- Vector databases
- Retrieval, reranking and citations
- RAG quality
🛠 Hands-on workshops
Assistant on documents2 h
Build a RAG on a document corpus.
✅ Deliverable : A RAG assistant
Day 7
Agent development
50% theory · 50% practice
- An agent's loop and tool calls
- Memory and planning
- Defining reliable tools
- Guardrails and human validation
- Use cases
Multi-agent systems
30% theory · 70% practice
- Orchestration patterns
- Roles and delegation
- Multi-agent frameworks
- Costs and complexity
- When to keep it simple
🛠 Hands-on workshops
Team of agents2 h
Orchestrate several agents on a business case.
✅ Deliverable : A multi-agent system
Day 8
Evaluating LLM applications
50% theory · 50% practice
- Why evaluate: non-determinism
- Test sets and metrics
- LLM-as-a-judge evaluation
- Regression tests
- Production monitoring
Securing LLM applications
30% theory · 70% practice
- Direct and indirect prompt injection
- Data leakage and exfiltration
- Tool and agent permissions
- Filtering and validation
- Security review
🛠 Hands-on workshops
Attack and defend2 h
Test an application's robustness against attacks.
✅ Deliverable : A report and fixes
Day 9
Deployment
50% theory · 50% practice
- Exposing an API with FastAPI
- Containerization
- Configuration and secrets
- Scaling and task queues
- Observability in production
Performance and costs
30% theory · 70% practice
- Measuring latency and cost per request
- Reducing prompt size
- Cache and batch processing
- Choosing the model just right for the need
- Dashboard
🛠 Hands-on workshops
Optimization1.5 h
Reduce an application's cost and latency.
✅ Deliverable : A before/after report
Day 10
Capstone project
30% theory · 70% practice
- Project finalization
- Testing, evaluation and security
- Documentation
- Preparing the presentation
- Peer review
🛠 Hands-on workshops
Project delivery3 h
Finalize the LLM application end to end.
✅ Deliverable : A deployed application
Sustainable AI and governance
50% theory · 50% practice
- AI sobriety and footprint
- Compliance: data, copyright, European framework
- Team usage policy
- Project defense
- Personal progression plan
Tools and technologies
API AnthropicAPI OpenAIChromaDBClaude CodeCursorDockerFastAPIGitGitHub CopilotLangChainLlamaIndexPythonVisual Studio Codepytest
Teaching methods
- Alternating lectures and daily hands-on work
- Capstone project built over the ten days
- Group code and evaluation reviews
- Comparison of tools on the team's real cases
Assessment
- Hands-on exercises corrected every day
- Evaluation of the capstone project
- Final defense before the group
Required equipment
- A computer with an internet connection
- Python 3, Git and a modern IDE
- Access to one or more code assistants and to a model API key (provided or personal)
- Docker (recommended for the deployment part)
Resources provided
- Course materials and repository of corrected exercises
- Code repository of the capstone project
- Evaluation grids and test sets
- Security and governance checklists
Career outcomes
- A complete LLM application, evaluated and deployed
- AI-assisted working methods the team can reproduce
- A grid of security, cost and governance best practices
Related video courses
My video courses that go with this program, to get ready for the training or to review afterwards. Free with an account.
Advanced Prompt Engineering
Go from a rough prompt to a professional method: structure your requests (R-C-T-C-O, RTF, CRAFT, RISEN), master advanced techniques (few-shot, chain of thought, personas, chaining), manage tokens and context, choose the right model at the right cost, control the output and use AI responsibly. You leave with a framework, checklists and a reusable prompt.
PYTHON
Learn the main concepts of PYTHON and get results by writing your first algorithms!
PYTHON OOP
Learn the main concepts of OBJECT-ORIENTED PYTHON and build your first design patterns!