Complete Agentic AI with LangChain

Session at a glance

The class follows a deliberate teaching order: understand the tools, understand the core mental model, then go hands-on with the one component everything else depends on — the model. The instructor repeatedly stressed depth over speed, because "every student who got a job said the depth is what helped them in interviews."

The Lang family: four offerings

LangChain (the company, San Francisco based) ships several products under one "Lang family." The instructor's framing: three of them build agents, one observes them.

The abstraction ladder

The three building tools sit at different levels of abstraction. Abstraction means hiding detail: lower level hides less and gives you more control; higher level hides more and gets you moving faster.

What LangSmith is for

You cannot understand an agent by reading its code, because at runtime an agent does many things — calls the LLM, reads/writes memory, invokes tools, talks to the user. LangSmith records the trace: when each step started, how long it took, how many tokens it used, where it failed.

Agent = Model + Harness

This is the load-bearing idea of the whole session, restated many times.

The LangChain journey

LangChain has a long history by AI standards, and its shape changed dramatically with version 1. Knowing the timeline explains why online tutorials look so different from each other.

Why LangChain? The philosophy

The pain LangChain removes: every provider's SDK is different. To call Claude, Gemini, and OpenAI directly you write three genuinely different shapes of code.

Environment setup

Coding demos run on Google Colab (so a weak/office laptop is never a blocker and everyone runs the exact same shared link), while real projects are built locally in VS Code with a proper virtual environment. The instructor uses uv for environments over pip/venv.

Keeping keys safe

Locally, load the key from .env; on Colab, use the Secrets panel via userdata. Either way LangChain reads it from the environment.

from google.colab import userdata
import os

OPENAI_API_KEY = userdata.get('OPENAI_API_KEY')
os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY

The sanity check

To confirm the setup works, run the official create_agent example — a tiny agent with one tool. Details of every argument come later; here it's purely an environment test.

from langchain.agents import create_agent

def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What's the weather in San Francisco?"}]}
)
print(result["messages"][-1].content_blocks)

If this runs on both Colab and VS Code, the environment is wired correctly. The point of the demo is the green light, not the arguments.

Models in depth

The model is the core of any agent, so the session deep-dives here before touching agents further. In v1, agents are central and the LLM is a component of the agent — but you still master the model first.

Two ways to get a model

You can instantiate a provider class directly (e.g. ChatOpenAI), or use the newer, recommended init_chat_model, which gives one uniform entry point across providers.

from langchain.chat_models import init_chat_model

openai_model = init_chat_model("openai:gpt-5-mini")

response = openai_model.invoke("In one line, tell me what is Langchain?")
print(response.content)

Sending structured messages

Beyond a bare string, you pass a list of typed message objects. This is where you actually control the model's behaviour — setting a role via a system message.

from langchain_core.messages import SystemMessage, HumanMessage

messages = [
    SystemMessage(content="You are a pirate, answer everything in pirate language"),
    HumanMessage(content="What is the capital of France?")
]

response = openai_model.invoke(messages)
print(response.content)  # "Arrr, the capital o' France be Paris, matey!"

The response object is rich

LangChain returns far more than text — and that extra data is what makes tracing and cost control possible "for the companies."

print("text:          ", response.text)
print("content_blocks:", response.content_blocks)
print("id:            ", response.id)
print("tool_calls:    ", response.tool_calls)

response.usage_metadata   # input_tokens, output_tokens, total_tokens, reasoning…

The model landscape

Any model is "a brain," and brains differ in capability — and in how you access them. Two independent axes were taught: free vs paid and closed vs open source. People constantly confuse the two, so keep them separate.

OpenRouter: one key, many models

OpenRouter is like LangChain-for-endpoints: one account and key that fronts 100+ models from all providers, at (for common models) the same price as going direct. You call it exactly like any other model in LangChain.

import os
from langchain.chat_models import init_chat_model

os.environ["OPENROUTER_API_KEY"] = "sk-or-v1-..."

# "auto" = OpenRouter picks a (possibly paid) model for you
model = init_chat_model("auto", model_provider="openrouter")

# A specific free model
free = init_chat_model("nvidia/nemotron-3-super-120b-a12b:free", model_provider="openrouter")

# "openrouter/free" = auto-route, but only across free models
free_auto = init_chat_model("openrouter/free", model_provider="openrouter")

response = model.invoke("Hello, which model are you?")

Q&A highlights

The doubt session surfaced several ideas worth keeping — especially one very common misconception about tools.

Active recall

Answer from memory before opening each one.

Quick revision