LangChain 1.0 Masterclass — agents, tools, memory, RAG & middleware

$ A minimal agent with one tool — a weather lookup that pings a free API

import requests
from dotenv import load_dotenv
from langchain.agents import create_agent
from langchain.tools import tool

load_dotenv()

@tool
def get_weather(city: str) -> str:
    """Return weather information for a given city."""
    response = requests.get(f"https://wttr.in/{city}?format=j1")
    return response.json()

agent = create_agent(
    model="gpt-4.1-mini",
    tools=[get_weather],
    system_prompt="You are a helpful weather assistant who always cracks jokes and is humorous while remaining helpful.",
)

response = agent.invoke({
    "messages": [{"role": "user", "content": "What is the weather like in Vienna?"}]
})
print(response["messages"][-1].content)

Expected shape of the output: a joke-laden weather report for Vienna, built from the wttr.in JSON the tool fetches. Treat the wording as illustrative rather than as a transcript - it comes from a live model call and varies by model and temperature. The model string "gpt-4.1-mini" is auto-recognized as OpenAI (verified: init_chat_model returns a ChatOpenAI instance), so langchain-openai must be installed and an OPENAI_API_KEY present, and an unrecognised model string fails with "Unable to infer model provider".

$ Structured output + context + memory — the agent locates the user, returns a typed response, and remembers the thread

from dataclasses import dataclass
from langchain.chat_models import init_chat_model
from langchain.tools import tool, ToolRuntime
from langgraph.checkpoint.memory import InMemorySaver

@dataclass
class Context:
    user_id: str

@dataclass
class ResponseFormat:
    summary: str
    temperature_celsius: float
    temperature_fahrenheit: float
    humidity: float

@tool
def locate_user(runtime: ToolRuntime[Context]) -> str:
    """Look up a user's city based on the context."""
    match runtime.context.user_id:
        case "ABC123": return "Vienna"
        case "XYZ456": return "London"
        case "HJKL111": return "Paris"
        case _: return "unknown"

model = init_chat_model("gpt-4.1-mini", temperature=0.3)
checkpointer = InMemorySaver()

agent = create_agent(
    model=model,
    tools=[get_weather, locate_user],
    system_prompt="You are a helpful weather assistant.",
    context_schema=Context,
    response_format=ResponseFormat,
    checkpointer=checkpointer,
)

config = {"configurable": {"thread_id": "1"}}
response = agent.invoke(
    {"messages": [{"role": "user", "content": "What is the weather like?"}]},
    config=config,
    context=Context(user_id="ABC123"),
)
print(response["structured_response"].summary)
print(response["structured_response"].temperature_celsius)

Expected output: a one-line summary such as "The current weather in Vienna is partly cloudy" followed by the temperature. The exact numbers depend on a live model call and on the weather, so read them as illustrative. What the example is really demonstrating is the wiring: the agent resolves the city from the user_id in context, is forced into the ResponseFormat shape, and - because of the InMemorySaver checkpointer - remembers the thread. Change thread_id to "2" and it forgets the earlier conversation.

$ RAG as a tool — turn a vector store into a retriever the agent can call

from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_core.tools import create_retriever_tool
from langchain.agents import create_agent

embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
texts = [
    "I love apples", "I enjoy oranges", "I think pears taste very good",
    "I hate bananas", "I dislike raspberries", "I despise mangoes",
    "I love Linux", "I hate Windows",
]
vector_store = FAISS.from_texts(texts, embedding=embeddings)
retriever = vector_store.as_retriever(search_kwargs={"k": 3})

retriever_tool = create_retriever_tool(
    retriever,
    name="knowledge_base_search",
    description="Search the small product/fruit knowledge base for information.",
)

agent = create_agent(
    model="gpt-4.1-mini",
    tools=[retriever_tool],
    system_prompt="You are a helpful assistant. If there are any questions about fruits, use the retriever tool first, retrieve the context, and answer concisely. You may need to use the tool multiple times.",
)

response = agent.invoke({
    "messages": [{"role": "user", "content": "What three fruits does the person like and what three fruits does the person dislike?"}]
})
print(response["messages"][-1].content)

The agent is expected to make two separate similarity searches, one for the likes and one for the dislikes, and combine them - which is the point of exposing retrieval as a tool instead of a fixed step in the code. The wording of the answer above is illustrative: reproducing it needs embedding and chat keys. This is the old-school RAG path: langchain-community + FAISS + create_retriever_tool, all three still importable in 1.x.

$ Middleware — swap the system prompt by user role, and swap the model by message count

from dataclasses import dataclass
from langchain.agents import create_agent
from langchain.agents.middleware import ModelRequest, ModelResponse, dynamic_prompt, wrap_model_call
from langchain.chat_models import init_chat_model

@dataclass
class Context:
    user_role: str

@dynamic_prompt
def user_role_prompt(request: ModelRequest) -> str:
    base = "You are a helpful and very concise assistant."
    match request.runtime.context.user_role:
        case "expert": return base + " Provide detailed technical responses."
        case "beginner": return base + " Keep your explanations simple and basic."
        case "child": return base + " Explain everything as if you were literally talking to a 5-year-old."
        case _: return base

agent = create_agent(
    model="gpt-4.1-mini",
    middleware=[user_role_prompt],
    context_schema=Context,
)

response = agent.invoke(
    {"messages": [{"role": "user", "content": "Explain PCA."}]},
    context=Context(user_role="child"),
)
print(response["messages"][-1].content)

Output for user_role="child" is illustrative - a live model call produces it, and the wording changes run to run. The mechanism is the point: @dynamic_prompt reads the role from request.runtime.context and rewrites the system prompt before the model is called. The same middleware pattern - wrap_model_call - lets you pick a stronger model when the message count crosses a threshold.