LangChain basic model
init_chat_model · create_agent · Streaming output

1What is the LangChain base model layer? Overview of core concepts

LangChain’s Module 1 starts with the most basic capabilities:How to call a large language model (LLM)? How to build an Agent that can remember conversations and call tools?

This section (1.1_foundational_models) focuses on the three most basic things:

• Initialize model:useinit_chat_modelUnify model interfaces from different vendors
• Build Agent:usecreate_agentPackage the model into an intelligent agent that can continue to dialogue
• Streaming output:useagent.stream()Let LLM's responses be displayed verbatim like a typewriter, rather than waiting until all are generated before displaying them

2init_chat_model: unified model initialization interface

Provided by LangChaininit_chat_modelFunction that unifies the initialization methods of different LLM providers. You just need to pass in the model name, provider identifier, and API key, and you'll get a standard chat model object.

Basic usage: Directly initialize Google Gemini

The simplest usage is to directly use the model class officially integrated by LangChain:

from langchain_google_genai import ChatGoogleGenerativeAI

# 直接初始化 Gemini 模型
model = ChatGoogleGenerativeAI(model="gemini-2.5-flash-lite")

# 直接调用：注意这是 model.invoke，不是 agent.invoke
response = model.invoke("What's the capital of the Moon?")
print(response.content)

Factory function that encapsulates DeepSeek

One is defined in the notebookdeepseek_model()Factory function encapsulates all DeepSeek related initialization details:

from dotenv import load_dotenv
load_dotenv()  # 从 .env 文件加载 DEEPSEEK_API_KEY 等环境变量

import os
from langchain.chat_models import init_chat_model

DEEPSEEK_MODEL = "deepseek-v4-flash"
DEEPSEEK_BASE_URL = "https://api.deepseek.com"

def deepseek_model(model: str = DEEPSEEK_MODEL, max_tokens=200, **kwargs):
    return init_chat_model(
        model=model,
        model_provider="deepseek",   # 或 "openai"（DeepSeek 兼容 OpenAI 格式）
        max_tokens=max_tokens,
        base_url=DEEPSEEK_BASE_URL,
        api_key=os.environ["DEEPSEEK_API_KEY"],
        **kwargs
    )

Initialize the model using a factory function:

model = deepseek_model(temperature=1)
print(model)  # 打印模型对象，确认配置

# 直接调用模型（不经过 Agent）
response = model.invoke("what is 1+1?")
print(response.content)  # → "The answer is 2."

Key parameters of init_chat_model

3create_agent: Build Agent with model

create_agentIt is a high-level API provided by LangChain, which packages a chat model into a completeLangGraph Agent(The bottom layer is a StateGraph with a checkpointer).

What does Agent have compared to the original model?

• Message history management:maintainmessagesList, supporting multiple rounds of dialogue
• Tool call: Tools can be bound and the model determines when to call them
• checkpointer: Persistent conversation state, supports cross-call memory
• System Prompt: Inject system prompts to define the role and behavior of the Agent

from langchain.agents import create_agent

# 最基础的用法：只传入模型
agent = create_agent(model=deepseek_model())

4Agent's invoke: synchronous call and response structure

Used to call Agentagent.invoke({"messages": [...]}), the input is a containingmessagesA dictionary of keys, messages can be usedHumanMessagePass in object or dictionary format.

Using the HumanMessage object

from langchain.messages import HumanMessage

agent = create_agent(deepseek_model())

messages = [
    {"role": "user",      "content": "what is 1+1?"},
    {"role": "assistant", "content": "2"},
    {"role": "user",      "content": "how about times 5?"}
]

response = agent.invoke({"messages": messages})
print(response['messages'][-1].content)

Structural analysis of response

The Agent's response is a dictionary, and the core keys aremessages, which is a message list containing the complete conversation history:

print(len(response['messages']))  # → 4（3 条输入 + 1 条 AI 响应）

for msg in response['messages']:
    print(msg.content)

5Streaming output (stream_mode="messages"): real-time printing by Token

use agent.invoke()You need to wait until all models are generated before you can see the results.agent.stream()Then let the model push it immediately every time it generates a token to achieve the "typewriter effect" - which is a much better experience in UI interaction and long response scenarios.

Basic streaming usage

messages = [{"role": "user", "content": "Tell me all about Luna City, the capital of the Moon"}]

for token, metadata in agent.stream(
    {"messages": messages},
    stream_mode="messages"   # 关键：按消息/token 流式推送
):
    if token.content:          # 过滤空 token（工具调用消息没有 content）
        print(token.content, end="", flush=True)  # 不换行，实时打印

stream_mode parameter description

6metadata metadata: understand the internal execution information of Agent

In a streaming loop,agent.stream()Return at the same timetoken(message content) andmetadata(execution metadata).metadataContains LangGraph internal runtime information, useful for debugging and tracing.

for token, metadata in agent.stream(
    {"messages": messages},
    stream_mode="messages"
):
    # 第一个 token 时打印 metadata
    print(metadata)
    break

Interpretation of metadata key fields

7Complete code and quick review of key concepts

Complete example from scratch

from dotenv import load_dotenv
load_dotenv()

import os
from langchain.chat_models import init_chat_model
from langchain.agents import create_agent
from langchain.messages import HumanMessage

# 1. 初始化模型
def deepseek_model(**kwargs):
    return init_chat_model(
        model="deepseek-v4-flash",
        model_provider="deepseek",
        api_key=os.environ["DEEPSEEK_API_KEY"],
        base_url="https://api.deepseek.com",
        max_tokens=500,
        **kwargs
    )

# 2. 构建 Agent
agent = create_agent(deepseek_model())

# 3. 同步调用
response = agent.invoke({"messages": [HumanMessage(content="Hello!")]})
print(response['messages'][-1].content)

# 4. 流式调用
for token, _ in agent.stream(
    {"messages": [{"role": "user", "content": "Tell me a joke"}]},
    stream_mode="messages"
):
    if token.content:
        print(token.content, end="", flush=True)

Summary of knowledge panorama in this section