Practical Applications of Large Language Model Algorithms: A Complete Tutorial Series from Basics to Advanced

This project is an open-source GitHub repository maintained by pmarcis (link: https://github.com/pmarcis/en-llm-lecture-examples, published on June 9, 2026), providing a series of Jupyter Notebook tutorials covering core LLM application scenarios such as text generation, question-answering systems, text classification, tool calling, and RAG. The tutorials use the OpenAI Python library and vLLM local deployment, supporting both rapid prototyping with cloud APIs and local deployment for privacy or cost-sensitive scenarios. The core goal is to demonstrate algorithm-level applications of LLMs rather than simple API calls.

This project is designed for educational and demonstration purposes, focusing on algorithmic interaction methods with LLMs. Its uniqueness lies in in-depth exploration of how to interact with LLMs in an algorithmic way, covering the complete technology stack from basic text generation to advanced structured output and tool calling. In terms of deployment, it supports OpenAI cloud API and vLLM local deployment, meeting different scenario needs (rapid validation vs. privacy/cost-sensitive production).

The repository contains 9 Jupyter Notebooks covering the following key areas:

1. Text Generation and Scoring: Basic generation + log probability quality assessment;
2. Dialogue Template Application: Use of chat templates for instruction-tuned models;
3. Question-Answering Systems: Basic common sense QA + context prompt engineering QA;
4. Text Classification and Structured Output: Structured result output for tasks like sentiment analysis and NER;
5. Prompt Engineering: Comparative experiments on the importance of precise instructions;
6. Security Protection: Risks such as jailbreak attacks and prompt injection, and mitigation techniques;
7. Tool Calling: LLMs calling external tools (calculators, search engines, etc.);
8. RAG Introduction: Implementing a simple Retrieval-Augmented Generation system with LangChain.

To run the examples, the following requirements must be met:

• Python 3.10+ (supports asynchronous programming and type hints);
• Jupyter Notebook/Lab (interactive environment);
• vLLM API endpoint (supports local deployment of models like Gemma3 or GPT-OSS; note that tool calling requires model support: GPT-OSS supports it, Gemma3 does not);
• Network connection (to download dependencies and models).

This tutorial has significant value for the following groups:

• AI application developers: Complete code references from concept to implementation to quickly master core technologies;
• Machine learning engineers: Deep understanding of algorithm-level interactions with LLMs (probability scoring, structured output control, etc.);
• Technical team leaders: Can be used as internal training materials to unify the team's technical understanding;
• Academic researchers: Provides a reproducible experimental environment, facilitating LLM behavior research and algorithm improvement.

The key takeaways from this project include:

1. Algorithmic thinking: Treating LLMs as programmable components rather than simple chat interfaces;
2. Security awareness: Understanding the security challenges of LLM applications (jailbreak, prompt injection) and protection strategies;
3. Engineering practice: Mastering the complete technical chain from local deployment to production integration;
4. Expansion capabilities: Extending the boundary of LLM capabilities through tool calling and RAG. This project is not only a collection of code examples but also a complete guide to engineering LLM usage.