2. LangChain Foundations - A Deep Dive

Create two API keys: one from OpenAI (Account → Settings → API Keys → Create new secret key; copy/save it) and one from Anthropic (Console/Platform → Manage → API Keys → Create secret key).

Set up a new project directory (e.g., Lang course) and initialize it with the uv package manager (uv init). Create and activate a virtual environment (uv venv, then source .venv/bin/activate on Mac; Windows differs).

Install dependencies via uv add: langchain, langchain-core, langgraph, langchain-openai, langchain-anthropic, and python-dotenv.

Create a .env file and store OPENAI_API_KEY and ANTHROPIC_API_KEY there.

In main.py, load environment variables with load_dotenv(), import the needed LangChain/LangGraph classes, and print package versions (using importlib.metadata to fetch versions).

Verify everything works by instantiating ChatOpenAI (e.g., gpt-4o-mini) and ChatAnthropic (e.g., Claude), invoking each with a simple prompt (like “setup complete in one word”), and confirming both return responses—indicating keys, dependencies, and the development environment are correctly set up.

The file demonstrates LangChain core concepts: LCEL (LangChain Expression Language) and runnables, using a simple “basic chain” example.

Imports added:

A function demo_basic_chain() is created to build and run the chain:

The components are composed using the pipe operator (|) (LCEL syntax):
chain = prompt | model | parser
This means: prompt → model → parser.

The chain is executed via the runnable interface using .invoke():
chain.invoke({"question": "What is LangChain?"})
The input key must match the template variable name (question). For multiple variables, they’d all be provided in the same input dict.

The result is printed (a one-sentence answer) and the chain can be returned from the function.

The next planned step is a batch execution demo to run the chain over multiple inputs.

Demonstrates how to do batch execution with an LCEL/LangChain runnable chain for multiple inputs.

Builds a chain using:

Prepares inputs as a list of dictionaries, each using the same key as the prompt variable (text), e.g.:

Runs all items at once via the runnable’s .batch(inputs) method (not “invoke batch”).

Iterates through zip(inputs, results) to print each English input alongside its French translation output.

Concludes that runnable chains expose methods like batch to efficiently process many inputs in one call, returning a corresponding list of results.

Builds a ChatPrompt (e.g., “write a haiku about {topic}”).

Creates a chat model (using ChatOpenAI, but any compatible model works).

Adds an output parser and composes them into a chain.

Streams results by iterating over chain.stream({ "topic": "nature" }), printing each returned chunk immediately (with flush) to mimic live output like ChatGPT.

It builds a standard chain: Prompt template → Chat model (e.g., GPT-4o-mini, temperature set) → Output parser, composed inline.

It then shows how to query the chain’s schemas:

Running the function prints the schemas:

The main point: LangChain lets you see the “bones” of what a runnable accepts and returns, helping understand how components compose internally without manual inspection.

The video explains a newer, “universal” way to initialize chat models in LangChain: using init_chat_model (imported from LangChain chat models) instead of directly instantiating provider-specific classes like ChatOpenAI.

The older approach (e.g., importing a provider wrapper and creating ChatOpenAI(…​) after loading env vars with load_dotenv) still works, but init_chat_model is recommended going forward for a unified setup across providers.

With init_chat_model, you pass parameters such as the model name/provider (e.g., GPT variants or Claude), temperature, and max_tokens, and it exposes additional configurable fields.

The video also lists example “available models” circa 2026 and their typical use cases:

Configuring chat models with init_chat_model, so you can easily swap providers like OpenAI and Anthropic.

Calling models with invoke to get responses, such as answering “What’s the capital of France?” with “Paris.”

Comparing multiple models by storing them in a dictionary and looping through them with the same prompt.

Using message objects like SystemMessage and HumanMessage from linkedchain_core.messages to better structure conversation context.

Understanding message metadata, since messages contain more than just text: role, content, and extra fields like response metadata and token usage.

Creating multi-turn conversations by appending the model’s AI response and follow-up human messages to the same message list.

Using system prompts for behavior control, like instructing the model to act like a pirate.

Chat prompt templates are reusable “cookie-cutter” structures for prompts. They contain placeholders/variables that get filled in at runtime, such as:

Templates improve reusability and organization because you define the structure once and reuse it with different values.

Multi-message templates separate prompts into different message roles, such as:

This structure helps ground the model by defining role, tone, and behavior in the system message while still allowing flexible user input.

The different message types are:

The conversation flow is typically system → human → AI → human → AI, and so on.

Few-shot prompting is introduced as a way to teach the model by example. By giving a few examples, the AI learns the pattern and can apply it to new inputs.

Prompt composition means building complex prompts from reusable parts:

Overall, the key benefits of these approaches are:

ChatPromptTemplate from template strings

Multi-message chat prompt templates

Message types

Few-shot chat message prompt templates

Reusable prompt components

LLMs often return plain strings, which are hard to work with directly.

Parsers help extract structured data like JSON, lists, and objects.

This makes downstream processing easier, supports error handling, and improves type safety.

String output parser: extracts clean text from an AI message, useful when you only need plain text.

JSON output parser: converts JSON-like model output into a Python dict, so fields can be accessed directly.

Pydantic output parser: uses a schema to validate and structure outputs, ensuring types and fields are correct.

They enforce schema validation.

They provide type hints and autocomplete support.

They handle errors more gracefully.

They are better suited for production apps with complex or nested data.

In newer LangChain versions, structured output is simpler and more recommended.

Instead of manually setting up parsers, instructions, and prompt templates, you can often use a one-line structured output method with a schema.

A movie review schema can extract:

StringOutputParser

JSONOutputParser

PydanticOutputParser

Structured Output (with_structured_output)