LangChain Tutorial: The Core Building Blocks | LLMs, JSON output, RAGs, Tools and Observability

LangChain’s practical value comes from a small set of reusable building blocks: a unified way to call different LLM providers, structured outputs that constrain responses to a schema, retrieval-augmented generation (RAG) for private documents, tool calling for actions, and observability so developers can trace every model call end-to-end. The tutorial walks through each piece with working examples, showing how the same core patterns carry across OpenAI, Google Gemini, and local models.

It starts with the simplest interface: initialize a chat model for a chosen provider and call it with a prompt. Using LangChain’s chat model initialization, the same “invoke with a prompt, read the response” workflow works for OpenAI (example: GPT-4 mini), Google GenAI (example: Gemini 2.5 Flash with a “thinking budget” and token/usage metadata), and local inference via Ollama (example: Qwen 8 billion). The transcript emphasizes what comes back from these calls: not just the answer text, but also metadata like finish reason and token usage, plus—depending on the model—reasoning content that can be enabled or suppressed.

Next comes chat orchestration. Instead of a single prompt string, LangChain uses a chat prompt template built from a system message and user messages, with template variables filled at runtime (the example swaps in an agent name like “Slim Shady”). Conversation history is maintained using typed message objects (system, human, AI), and subsequent turns reuse that history to keep context. The tutorial also demonstrates how to disable “thinking” so outputs stay concise.

Structured output is presented as a reliability lever. By defining a Pydantic model (a “song classification” schema with fields like song name, style enum, and reasoning), the model is forced to return JSON that matches the schema. Two lyric-based classification attempts show the tradeoff: the structure is correct even when the factual fields are wrong, and the reasoning field can still be useful. The key takeaway is that schema-constrained outputs reduce format-related hallucinations and make downstream parsing safer.

For private knowledge, the tutorial builds a minimal RAG pipeline over a PDF. It loads a two-page Aston Martin Valhalla document using PyPDF, embeds the pages with FastEmbed (locally), stores vectors in an in-memory vector store, and retrieves the most similar page(s) for a query. A Q&A prompt then instructs the model to answer only from retrieved context and to say “I don’t know” when information is missing. The example queries (engine type, horsepower, 0–60 acceleration) demonstrate that even without chunking, the retrieved context can be sufficient for accurate answers.

Tool calling ties the pieces together. A LangChain tool (decorated function) wraps the RAG “answer query” logic. The model is bound to this tool and returns tool-call arguments; the system executes the tool and feeds the tool result back into the conversation. The example asks for the Valhalla transmission, and the final response incorporates the PDF-derived answer.

Finally, observability is handled through MLflow integration (MLflow 3 release mentioned). By running an MLflow tracking server locally and viewing traces in the MLflow UI, developers can inspect each request, prompt, response, timing, and model metadata—turning “it worked” into traceable, debuggable behavior across chat, RAG, and tool calls.