AI curriculum

Course outline for Building Applications with LLMs

Build one useful application that combines a language model, an external service, structured outputs, conversation context, and retrieved documents. Learn the underlying request and tool flow, then use LangChain to connect the components. Keep memory and stored application data explicit and test the application's behavior when a service, model output, or retrieval result fails.

Building Applications with LLMs Course Objectives

  • Build a runnable model-backed application using basic LangChain components.
  • Integrate an actual external HTTP service through model-selected tool calling.
  • Validate tool arguments, service results, and structured model outputs.
  • Manage conversation context and distinguish it from persistent application records.
  • Add a basic retrieval-augmented generation path over a small document collection.
  • Test the integrated app's success, missing-evidence, and dependency-failure paths.

Pre-requisites

  • Write and test small Python programs and work with HTTP and JSON.
  • Programming Language Concepts for AI Engineers and Applied Generative AI, or equivalent programming and model-interaction competence.
  • Software Engineering Foundations for AI Engineers delivery and testing practices are recommended.
  • No prior LangChain, vector-database, or RAG-course experience is required.

Before this course

Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.

Required preparation

Recommended preparation

Readiness checks

  • Write and test small Python programs and work with HTTP and JSON.
  • Programming Language Concepts for AI Engineers and Applied Generative AI, or equivalent programming and model-interaction competence.
  • Software Engineering Foundations for AI Engineers delivery and testing practices are recommended.
  • No prior LangChain, vector-database, or RAG-course experience is required.

Can write and test small Python programs and use HTTP and JSON, with model-interaction competence; no prior LangChain, vector database, or RAG-course experience is required.

Find your place in the learning map

Lab Setup

Delivery requirements: the following environment, materials, access, and exercise timing must be prepared and verified before delivery. This outline does not certify that a lab package is ready.

A verified Python/LangChain environment, a minimal interface and storage scaffold, a small handbook, an embedding model/local index, and model access supporting the selected tool and structured-output path. Tool use and structured generation may be separate bounded stages if simultaneous support is unavailable; verify the actual combination before delivery. Provide the exact stable versions and official setup instructions during lab preparation. The instructor must verify external-service access, applicable usage terms, attribution, quotas, and any commercial-training costs. Open-Meteo is a documented candidate, not a promise of unrestricted free use. Use synthetic event data and no production credentials. Mocks support failure tests; they do not replace the required real external integration. If access fails, report the blocked objective or arrange an approved alternative service rather than claim equivalent completion.

Detailed Course Outline

Module 1: Application foundations and LangChain basics (2 hours)

  • Application request path: User request, model call, application logic, and response path.
  • Direct model calls: A minimal direct SDK/API call before framework abstractions.
  • LangChain basics: LangChain model interfaces, messages, prompts, and component composition.
  • Configuration and model capabilities: Configure credentials and check the capabilities supported by the selected model.
  • Structured output validation: Validate JSON/schema-constrained model output again in application code before use.
  • Framework trade-offs: Framework benefits, dependencies, and when a direct SDK is simpler.

Practical outcome: Run a small LangChain feature that returns a validated structured plan.

Module 2: External services through tool calling (2 hours)

  • Typed tool inputs: Tool descriptions, typed arguments, schemas, and allowed inputs.
  • Tool selection and execution: Distinguish model-selected tool calls from their execution by application code.
  • External weather HTTP adapter: Calling an external weather API through a real HTTP adapter.
  • Service result validation: Service response validation, units, timestamps, and normalized tool results.
  • Tool-result response flow: Returning the actual tool result for a structured final response.
  • Dependency failure handling: Timeouts, invalid arguments, service errors, and bounded retries.

Practical outcome: Obtain a real forecast through a tool and incorporate it into a checked plan.

Module 3: Context, memory, and basic RAG (2 hours)

  • Conversation identity and limits: Manage conversation history, thread identity, and the limits of a context window.
  • Context policy: Trimming history and summarization trade-offs; implement one simple context policy.
  • Memory, storage, and weights: Short-term conversation memory versus cross-session storage and model weights.
  • Handbook ingestion and embeddings: Loading and chunking a small handbook; embeddings and a local retriever.
  • Retrieval before generation: Retrieving passages and supplying them as context before generation.
  • Sources and missing evidence: Source references, missing evidence, and retrieval versus remembering a conversation.

Practical outcome: Answer a follow-up using conversation context and a new question using retrieved passages.

Module 4: Integration, persistence, and failure checks (2 hours)

  • Combining tools and retrieval: Combine external-service data and handbook passages in the same app.
  • Selected-plan storage: Save selected plans separately from conversation history and transient context state.
  • Confirmed writes: Confirm a requested write and verify the stored result.
  • Execution records: Record basic logs and the model, tool, and retrieval execution steps.
  • Failure and integration tests: Deterministic failure tests plus a real model/service integration run.
  • Reproducible framework setup: Reproducible setup and boundaries of the selected framework components.

Practical outcome: Demonstrate one working app with external tools, structured output, memory, and basic RAG.

Practical exercise

  • Build an event-planning assistant using LangChain and a minimal interface scaffold. Given a location, date within the service's forecast range, and user preferences, let the model request a forecast from an external service such as Open-Meteo. The application validates arguments, makes the HTTP call, checks and normalizes the returned data, and sends the actual result back to the model. Retrieve relevant passages from a small event handbook and generate a structured plan with source references and explicit weather units and times.
  • Ask a follow-up that depends on earlier preferences. Start a fresh conversation and show that it does not inherit another thread's history. Save a chosen plan to a file or embedded store and verify it after reopening the app. Test invalid tool arguments, an unavailable weather service, malformed structured output, and a handbook question with no supporting passage.

What you will produce

Build a Python/LangChain app with a real external HTTP tool, checked structured output, isolated conversation context, basic RAG, and persistent selected plans.

How the work is checked

  • The learner can identify model, tool, retriever, memory, and storage responsibilities.
  • A model-selected tool call causes a real external-service request, not a hard-coded response.
  • Structured output passes schema checks and agrees with the observed service data.
  • Conversation context supports a follow-up without leaking across unrelated threads.
  • A retrieved handbook passage supports a new answer and its source reference.
  • Missing evidence and service failure do not produce invented facts.
  • Saved application records survive reopening independently of transient chat memory.
  • The learner explains what LangChain supplies and what application code still controls.

Eight guided hours include demonstrations, practice, feedback, and questions. Breaks and pre-course setup are outside the total. One incremental Python application uses hands-on LangChain basics, one external read-only service, a tiny document collection, and one simple context policy. Tool calling and structured generation can use separate bounded stages if simultaneous support is unavailable. Retrieval supplies context, not weight updates or automatic personal long-term memory. Transient conversation state does not survive restart; selected plans use explicit persistent storage. Advanced memory stores, LangGraph engineering, autonomous multi-agent systems, and full web-stack work are outside scope. Streaming is optional. Retrieval-Augmented Generation develops deeper retrieval methods; Agent Platforms and Frameworks compares frameworks. Prepared scaffolds, a timed pilot, and verified service terms, attribution, quotas, and costs are delivery prerequisites. Extend practice if needed rather than replace required real runs with traces.

When another approach is better

  • Use a direct SDK when framework abstractions add unnecessary dependencies.
  • Use a simple deterministic service call when model-selected tools add no task value.
  • Use specialist RAG or orchestration training for production retrieval or autonomous multi-agent systems.

How we train

Contact us for full course details, including duration, delivery options and lab requirements.

Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.

Discuss your learning goals