Understand LLMs
Learn how language models, prompts, embeddings, and RAG workflows work.
Data & AI · LLM applications and responsible AI
Generative AI
Learn large language model application design, prompting, embeddings, retrieval-augmented generation, agents, evaluation, AI safety, and responsible deployment.
Move from prompt engineering and LLM fundamentals to a complete RAG Chatbot that retrieves relevant documents, generates grounded answers, and includes evaluation and safety considerations.
Course overview
Generative AI refers to AI systems that can create text, images, code, audio, or other content based on user input. Large language models are commonly used for conversation, summarization, content generation, classification, and knowledge-based question answering.
This course introduces generative-AI concepts, prompt design, LLM application workflows, embeddings, vector search, retrieval-augmented generation, agents, evaluation, safety, privacy, and deployment considerations.
The proposed capstone is a RAG Chatbot for a chosen approved knowledge base. The project covers document preparation, embedding, retrieval, prompt design, answer generation, citations, evaluation, and responsible-use documentation.
A useful generative-AI application should not only generate responses. It should use appropriate context, cite sources where possible, handle uncertainty, protect private data, and make limitations clear to users.
Prerequisites
This course is designed for learners with basic programming and AI familiarity.
- Basic Python programming knowledge.
- Comfort with functions, lists, dictionaries, and JSON.
- Basic understanding of APIs and web concepts.
- Basic machine-learning awareness is recommended.
- Basic command-line familiarity is helpful.
- Prior generative-AI experience is not required.
Readiness activity
Write a prompt asking an AI assistant to summarize a short article. Identify the task, context, output format, and constraints included in the prompt.
Who can explore this course?
Build AI applications
Create AI-powered tools using APIs, retrieval, and application logic.
Design AI features
Explore chatbots, assistants, search, summarization, and knowledge-base applications.
Build an AI portfolio
Develop a documented RAG chatbot with evaluation and responsible-use notes.
What you will learn
- Explain generative AI, LLMs, tokens, and model limitations.
- Design clear, structured, and testable prompts.
- Use system, user, and assistant message roles.
- Apply few-shot prompting and output-format constraints.
- Understand embeddings and semantic similarity.
- Use vector databases and retrieval concepts.
- Build a retrieval-augmented generation workflow.
- Generate grounded answers with source citations.
- Explore agent concepts, tools, and task planning.
- Evaluate response quality, relevance, and factual grounding.
- Apply privacy, safety, bias, and responsible-use practices.
- Document and present a generative-AI application.
Curriculum outline
The ten-module outline moves from generative-AI fundamentals to a complete RAG Chatbot project. Exact model provider, vector database, framework, and deployment platform should be confirmed before delivery.
01
Generative AI fundamentals
Understand what generative AI is, how language models generate text, and where they are useful.
- AI, machine learning, and generative AI.
- Large language models and tokens.
- Prompts, context, and model responses.
- Text, image, code, and multimodal generation.
- Common LLM use cases.
- Model limitations and hallucinations.
Practice: Identify a suitable and unsuitable use case for an LLM and explain the reason.
02
Development environment and tools
Set up a Python-based AI development workflow and learn how to organize an LLM application project.
- Python environments and packages.
- API keys and environment variables.
- LLM provider concepts.
- Jupyter Notebook and VS Code workflows.
- Project structure and configuration.
- Git and GitHub basics.
Practice: Create a project folder, configure environment variables securely, and run a simple LLM API request.
03
Prompt engineering
Design effective prompts that produce clearer, more consistent, and more useful model outputs.
- Prompt structure and instructions.
- System, user, and assistant roles.
- Context, constraints, and examples.
- Few-shot prompting.
- Structured output and JSON formatting.
- Prompt iteration and testing.
Practice: Improve a vague prompt into a structured prompt with role, task, context, format, and constraints.
04
LLM application design
Design LLM-powered features with clear user goals, inputs, outputs, and safety boundaries.
- Chatbots, assistants, and copilots.
- Summarization and content-generation workflows.
- Classification and extraction tasks.
- Conversation state and memory concepts.
- User experience and response formatting.
- Handling unclear or unsupported requests.
Practice: Design a simple AI assistant and define its purpose, inputs, outputs, limitations, and safety rules.
05
Embeddings and semantic search
Understand how text can be represented as embeddings and used for semantic search.
- Embeddings and vector representations.
- Similarity, distance, and relevance.
- Text chunking strategies.
- Vector databases and indexes.
- Metadata and filtering.
- Search-result evaluation.
Practice: Create embeddings for a small document collection and retrieve the most relevant passages for sample questions.
06
Retrieval-augmented generation
Build RAG workflows that retrieve relevant information before generating a response.
- RAG workflow and components.
- Document ingestion and preprocessing.
- Chunking, embedding, and indexing.
- Retrieval and context construction.
- Prompting with retrieved context.
- Citations and source attribution.
Practice: Build a basic RAG pipeline that answers questions using approved documents and includes source references.
07
Agents, tools, and workflows
Explore how LLM applications can use tools and structured workflows to complete multi-step tasks.
- Agents and task planning concepts.
- Tools, functions, and API calls.
- Structured outputs and decision flows.
- Multi-step reasoning and task decomposition.
- Human review and approval points.
- Agent limitations and failure handling.
Practice: Design a simple agent workflow that uses one approved tool and includes a human-review step.
08
Evaluation, testing, and quality
Measure the quality of prompts, retrieval, and generated responses using structured evaluation methods.
- Evaluation datasets and test questions.
- Relevance, accuracy, and completeness.
- Groundedness and citation quality.
- Human review and rubrics.
- Automated evaluation concepts.
- Regression testing and prompt versioning.
Practice: Create an evaluation table with questions, expected answers, retrieved sources, and quality notes.
09
AI safety, privacy, and responsible use
Apply responsible-AI practices across data, prompts, outputs, users, and deployment.
- Privacy, confidentiality, and data minimization.
- Bias, fairness, and representation concerns.
- Hallucinations and uncertainty.
- Prompt injection and misuse risks.
- Content safety and moderation concepts.
- Transparency, disclosures, and human oversight.
Practice: Create a responsible-use checklist covering data, access, outputs, escalation, and user communication.
10
Capstone delivery
Complete the RAG Chatbot project and prepare a professional demonstration with documentation and evaluation results.
- Define the chatbot purpose and users.
- Prepare and document the knowledge base.
- Build retrieval and generation workflow.
- Design prompts and response format.
- Add citations and uncertainty handling.
- Evaluate answers and document limitations.
- Prepare deployment and responsible-use notes.
Practice: Submit a complete RAG Chatbot with README, evaluation results, source citations, and safety notes.
Practical exercise ideas
Complete these smaller activities before assembling the final RAG Chatbot project.
Prompt improvement
Improve a vague prompt by adding role, context, format, constraints, and examples.
Summarization tool
Build a simple tool that summarizes approved text into bullet points.
Semantic search
Create embeddings for sample documents and retrieve relevant passages for test questions.
Document Q&A
Build a basic RAG workflow that answers questions using approved documents.
Answer review
Review generated answers for relevance, accuracy, groundedness, and citation quality.
Responsible-use checklist
Create rules for private data, unsupported questions, uncertainty, and human escalation.
Suggested eight-week learning plan
This is an illustrative learning sequence. Confirm the academy's official timetable, model provider, vector database, framework, and assessment requirements before publishing.
| Week | Focus | Suggested milestone |
|---|---|---|
| 01 | Generative AI and LLM fundamentals | Explain LLM capabilities, prompts, and limitations. |
| 02 | Environment and prompt engineering | Build and test structured prompts. |
| 03 | LLM application design | Design an AI feature with inputs and safety rules. |
| 04 | Embeddings and semantic search | Retrieve relevant passages from a sample knowledge base. |
| 05 | Retrieval-augmented generation | Build a basic RAG workflow with citations. |
| 06 | Agents, tools, and workflows | Design a simple tool-using workflow with review. |
| 07 | Evaluation, safety, and deployment | Evaluate answers and document responsible-use rules. |
| 08 | Capstone presentation | Submit and present the RAG Chatbot. |
Turn knowledge into grounded answers
Capstone project
RAG Chatbot
Build a retrieval-augmented chatbot for a chosen approved knowledge base. Possible examples include a course FAQ bot, product-support assistant, internal policy assistant, student helpdesk, or another suitable educational chatbot.
Core project requirements
- Define the chatbot purpose, users, and supported questions.
- Use only approved, licensed, or original source documents.
- Clean, chunk, and document the knowledge base.
- Create embeddings and store them in a vector database or equivalent.
- Retrieve relevant context for user questions.
- Design a prompt that uses retrieved context and avoids unsupported claims.
- Generate concise, grounded answers with source citations.
- Handle missing, unclear, or unsupported questions safely.
- Evaluate answers using a test-question set.
- Document privacy, safety, limitations, and responsible-use rules.
Quality requirements
- Use clear and factual source documents.
- Keep raw documents, processed chunks, and evaluation results separate.
- Use meaningful chunk sizes and metadata.
- Return citations or references where possible.
- Do not expose API keys, private documents, or user data.
- Use environment variables for secrets and configuration.
- Test relevant, irrelevant, ambiguous, and unsupported questions.
- Clearly state when the chatbot cannot answer from available sources.
- Review outputs for bias, safety, accuracy, and clarity.
- Provide a README with setup, usage, evaluation, and limitations.
Retrieval improves grounding, but it does not guarantee accuracy. A RAG chatbot should still be evaluated, monitored, and designed to acknowledge uncertainty.
Suggested project structure
Keep documents, retrieval logic, prompts, evaluation, and application code separate for maintainability.
rag-chatbot/
├── data/
│ ├── raw/
│ ├── processed/
│ └── README.md
├── src/
│ ├── config.py
│ ├── ingest.py
│ ├── embeddings.py
│ ├── retriever.py
│ ├── prompts.py
│ ├── chatbot.py
│ └── evaluate.py
├── tests/
├── evaluations/
├── .env.example
├── .gitignore
├── requirements.txt
└── README.md
Do not commit API keys, private documents, user data, database credentials, or confidential business information to a public repository.
RAG chatbot workflow
RAG applications are iterative. Evaluation results, user feedback, new documents, and safety requirements may require changes to chunking, retrieval, prompts, or response rules.
Prepare documents
Collect approved sources, clean text, add metadata, and document limitations.
Embed and store
Chunk documents, create embeddings, and store vectors with useful metadata.
Find relevant context
Convert user questions into embeddings and retrieve the most relevant passages.
Answer with context
Use a structured prompt to generate a grounded response with citations.
Measure quality
Review relevance, accuracy, groundedness, citations, and unsupported claims.
Iterate safely
Improve retrieval, prompts, and safeguards based on test results and feedback.
A RAG system combines retrieval and generation: it first finds relevant source material, then asks the language model to answer using that material.
Tools and technologies
The exact model provider, vector database, and framework may vary by delivery. The proposed toolkit focuses on practical LLM application and RAG workflows.
- Python
- LLM APIs
- Prompt engineering
- Embeddings
- Vector databases
- RAG concepts
- LangChain concepts
- LlamaIndex concepts
- Chroma concepts
- FAISS concepts
- Git
- GitHub
- VS Code
Supporting concepts
- Tokens, context windows, and model limitations.
- Prompt roles, examples, and structured outputs.
- Document ingestion, chunking, and metadata.
- Similarity search and retrieval evaluation.
- Agents, tools, and human oversight.
- Privacy, safety, bias, and responsible deployment.
Learning outcomes
By completing the proposed lessons and exercises, aim to demonstrate the following abilities:
- Explain generative AI and LLM application concepts.
- Design clear, structured, and testable prompts.
- Build simple LLM-powered text workflows.
- Understand embeddings and semantic search.
- Build a retrieval-augmented generation workflow.
- Generate grounded answers with source citations.
- Design simple agent workflows with human oversight.
- Evaluate response relevance, accuracy, and groundedness.
- Apply privacy, safety, and responsible-use practices.
- Document and present a RAG Chatbot project.
These are learning objectives, not guarantees of employment, certification, placement, or a specific AI role. Progress depends on programming, prompt design, evaluation, data quality, and continued learning.
Related career interests
Illustrative directions for continued learning, not job or placement guarantees.
- Junior Generative AI Developer
- AI Application Developer Trainee
- LLM Engineer Trainee
- AI Product Trainee
- Machine Learning Engineer Trainee
- Technology Trainee
- Associate Engineer
- Support / Implementation Engineer
Portfolio presentation ideas
- Explain the chatbot purpose, users, and knowledge base.
- Show document preparation and chunking decisions.
- Explain embeddings, retrieval, and prompt design.
- Demonstrate answers with citations and uncertainty handling.
- Present evaluation results and failure examples.
- Discuss privacy, safety, bias, and limitations.
Frequently asked questions
Who is this course for?
It is suitable for Python learners, developers, AI enthusiasts, and product builders who want to understand LLM applications and RAG workflows.
Do I need machine-learning experience?
Basic machine-learning awareness is recommended. The course introduces generative-AI concepts before moving into practical application development.
Do I need coding skills?
Basic Python knowledge is recommended. The course includes practical exercises using Python, APIs, prompts, embeddings, and retrieval workflows.
Will the course cover prompt engineering?
Yes. It covers prompt structure, roles, context, examples, constraints, structured outputs, and prompt iteration.
Will the course cover RAG?
Yes. It covers document ingestion, chunking, embeddings, vector search, retrieval, grounded generation, citations, and evaluation.
Will the course cover AI agents?
Yes. It introduces agent concepts, tools, task planning, structured workflows, limitations, and human-review points.
What is the capstone project?
The proposed capstone is a RAG Chatbot that retrieves relevant documents, generates grounded answers, includes citations, and documents evaluation and safety considerations.
Do I need an AI API key?
API access may be required for practical exercises. Confirm the academy's approved provider, account setup, usage limits, and security rules before enrollment.
How long is the course?
The supplied course information proposes a duration of eight weeks. Confirm the academy's official schedule, tools, model access, and assessment requirements.
Does this course guarantee a job?
No. The course can support practical learning and portfolio development, but it does not guarantee employment, placement, certification, or salary.
How do I enroll?
This page is a frontend course-information demonstration. Enrollment, payment, scheduling, and admission workflows are not implemented here.
Build grounded, responsible AI experiences
Build your RAG Chatbot
Study LLM application design, prompting, embeddings, retrieval-augmented generation, agents, evaluation, and AI safety through a practical portfolio project.