LangChain 核心组件之 Models

1from langchain.chat_models import init_chat_model
2
3model = init_chat_model(model='ollama:gemma4:e4b')
4
5response = model.invoke("Tell me a joke.")
6print(response)

1response = model.invoke([HumanMessage(content="Tell me a joke.")])

1conversation = [{"role": "user", "content": "Tell me a joke."}]
2response = model.invoke(conversation)
3
4conversation.append({"role": "assistant", "content": response.content})
5
6conversation.append({"role": "user", "content": "another none"})
7response = model.invoke(conversation)
8print(response.content)

1model.invoke([
2    {"role": "user", "content": "Tell me a joke."},
3    {"role": "assistant", "content": "Why did the scarecrow win an award?\n\nBecause he was outstanding in his field! 😂"},
4    {"role": "user", "content": "another none"}
5])

1model.invoke([
2    SystemMessage(content="You are a joke maker."),
3    HumanMessage(content="Tell me a joke."),
4    AIMessage(content="Why did the scarecrow win an award?\n\nBecause he was outstanding in his field! 😂"),
5    HumanMessage(content="another none")
6])

1response = model.invoke([
2    ("user", "Tell me a joke."),
3    ("assistant", "Why did the scarecrow win an award?\n\nBecause he was outstanding in his field! 😂"),
4    ("user", "another none")
5])

 1from io import StringIO
 2from langchain.chat_models import init_chat_model
 3
 4model = init_chat_model(
 5    model='ollama:gemma4:e4b',
 6)
 7
 8last_message = StringIO()
 9for chunk in model.stream("tell me a joke"):
10    print(chunk.text, end="", flush=True) # AIMessageChunk
11    print(chunk.text, file=last_message, end="", flush=True)
12
13print("\n---\n")
14
15for chunk in model.stream([
16    {"role": "user", "content": "Tell me a joke."},
17    {"role": "assistant", "content": last_message.getvalue()},
18    {"role": "user", "content": "another none"}
19]):
20    print(chunk.text, end="", flush=True)

1Why did the scarecrow win an award?
2
3...Because he was outstanding in his field! 🏆🌽😄
4---
5
6Why don't scientists trust atoms?
7
8...Because they make up *everything*! ⚛️😉

 1from io import StringIO
 2from langchain.chat_models import init_chat_model
 3
 4model = init_chat_model(
 5    model='ollama:gemma4:e4b',
 6    reasoning=True
 7)
 8
 9last_message = StringIO()
10for chunk in model.stream("tell me a joke"):
11    print(chunk.text, end="", flush=True) # AIMessageChunk
12    print(chunk.text, file=last_message, end="", flush=True)
13
14print("\n---\n")
15stopped_thinking = False
16
17for chunk in model.stream([
18    {"role": "user", "content": "Tell me a joke."},
19    {"role": "assistant", "content": last_message.getvalue()},
20    {"role": "user", "content": "another none"}
21]):
22    thinking = chunk.additional_kwargs.get("reasoning_content", "")
23
24    if thinking:
25        print(f"\033[32m{thinking}", end="", flush=True)
26    else:
27        if stopped_thinking == False and len(chunk.text) > 0:
28            print("\n---\n")
29            stopped_thinking = True
30
31        print(f"\033[0m{chunk.text}", end="", flush=True)

1{"model":"gemma4:e4b","stream":true,"options":{},"messages":[{"role":"user","content":"Hello"}],"tools":[]}
2{"model":"gemma4:e4b","stream":true,"options":{},"messages":[{"role":"user","content":"Hello"}],"tools":[],"think":true}
3{"model":"gemma4:e4b","stream":true,"options":{},"messages":[{"role":"user","content":"Hello"}],"tools":[],"think":false}

1responses = model.batch([
2    "Why do parrots have colorful feathers?",
3    "How do airplanes fly?",
4    "What is quantum computing?"
5])
6for response in responses:
7    print(response)

1for response in model.batch_as_completed([
2    "Why do parrots have colorful feathers?",
3    "How do airplanes fly?",
4    "What is quantum computing?"
5]):
6    print(response)

1model.batch(
2    list_of_inputs,
3    config={'max_concurrency': 5}
4)

 1from langchain.chat_models import init_chat_model
 2from langchain.tools import tool
 3
 4@tool
 5def get_weather(location: str) -> str:
 6    """Get the weather at a location."""
 7    return f"It's sunny in {location}."
 8
 9model = init_chat_model(model="ollama:gemma4:e4b")
10
11model_with_tools = model.bind_tools([get_weather])
12
13response = model_with_tools.invoke("What's the weather like in Boston?")
14print(response.tool_calls)
15print(response.content_blocks)

 1conversation = [{"role": "user", "content": "What's the weather like in Boston?"}]
 2response = model_with_tools.invoke(conversation)
 3conversation.append(response)
 4
 5for tool_call in response.tool_calls:
 6    tool_result = globals()[tool_call["name"]].invoke(tool_call["args"])
 7    conversation.append({"role": "tool", "content": tool_result, "tool_call_id": tool_call["id"]})
 8
 9response = model_with_tools.invoke(conversation)
10print(response.content)

1model_with_tools = model.bind_tools([tool_1, tool_2], tool_choice="any")

 1from langchain.tools import tool
 2from langchain.chat_models import init_chat_model
 3
 4@tool
 5def tool_1(filepath: str) -> str:
 6    """read file content by filepath"""
 7    return "I'm a cat"
 8
 9@tool
10def tool_2(filepath: str, content: str) -> str:
11    """write file content by filepath and content"""
12    return "updated file " + filepath
13
14
15model = init_chat_model(
16    model='ollama:llama3.2:1b',
17)
18model_with_tools = model.bind_tools([tool_1, tool_2], tool_choice="any")
19
20response = model_with_tools.invoke("hello")
21print("content: ", response.content)
22print("tool_calls: ", response.tool_calls)
23print("content_blocks: ", response.content_blocks)

1model_with_tools = model.bind_tools([tool_1, tool_2], tool_choice="tool_2")

1model_with_tools = model.bind_tools([tool_1, tool_2], tool_choice="any")
2response = model_with_tools.invoke("use tool_1 to load file 'hello.txt', and explain content")

1model = init_chat_model(
2    model='ollama:gemma4:e4b',
3)
4model_with_tools = model.bind_tools([tool_1, tool_2], tool_choice="tool_1")
5
6response = model_with_tools.invoke("hello")
7print("content: ", response.content)
8print("tool_calls: ", response.tool_calls)
9print("content_blocks: ", response.content_blocks)

1model_with_tools = model.bind_tools([tool_1, tool_2])
2response = model_with_tools.invoke("read file 1.txt and 2.txt, merge and summarize")

 1from langchain.chat_models import init_chat_model
 2
 3from pydantic import BaseModel
 4
 5class Winner(BaseModel):
 6    first_name: str
 7    last_name: str
 8    birth_year: int
 9
10model = init_chat_model(
11    model='ollama:gemma4:e4b',
12)
13
14model_with_structure = model.with_structured_output(Winner)
15response = model_with_structure.invoke("Get one who won the Nobel Prize in Chemistry in 2020?")
16print("type: ", type(response), "\n", response)

1type:  <class 'dict'> 
2 {'first_name': 'Peter', 'last_name': 'Wouter', 'birth_year': 1953}

1from typing_extensions import TypedDict, Annotated
2
3class Winner(TypedDict):
4    first_name: Annotated[str, ...]
5    last_name: Annotated[str, ...]
6    birth_year: Annotated[int, ...]

1{"properties":{"first_name":{"title":"First Name","type":"string"},"last_name":{"title":"Last Name","type":"string"},
2"birth_year":{"title":"Birth Year","type":"integer"}},"required":["first_name","last_name","birth_year"],"title":"Winner","type":"object"}
3''')
4
5model_with_structure = model.with_structured_output(json_schema, method="json_schema")
6response = model_with_structure.invoke("Get one who won the Nobel Prize in Chemistry in 2020?")
7print("type: ", type(response), "\n", response)

1type:  <class 'dict'> 
2 {'first_name': 'Peter', 'last_name': 'Wouter', 'birth_year': '1959'}

 1class Winner(BaseModel):
 2    first_name: str
 3    last_name: str
 4    birth_year: int
 5
 6class Winners(BaseModel):
 7    winners: list[Winner]
 8
 9model = init_chat_model(
10    model='ollama:gemma4:e4b',
11)
12
13model_with_structure = model.with_structured_output(Winners)
14response = model_with_structure.invoke("Get who won the Nobel Prize in Chemistry in 2020?")
15print("type: ", type(response), "\n", response)

1model = init_chat_model(
2    model='gemini-2.5-flash',
3    model_provider='google_genai'
4)
5
6print(json.dumps(model.profile, indent=2))

 1{
 2  "max_input_tokens": 1048576,
 3  "max_output_tokens": 65536,
 4  "text_inputs": true,
 5  "image_inputs": true,
 6  "audio_inputs": true,
 7  "pdf_inputs": true,
 8  "video_inputs": true,
 9  "text_outputs": true,
10  "image_outputs": false,
11  "audio_outputs": false,
12  "video_outputs": false,
13  "reasoning_output": true,
14  "tool_calling": true,
15  "structured_output": true,
16  "image_url_inputs": true,
17  "image_tool_message": true,
18  "tool_choice": true
19}

1custom_profile = {
2    "max_input_tokens": 100_000,
3    "tool_calling": True,
4    "structured_output": True,
5    # ...
6}
7model = init_chat_model("...", profile=custom_profile)

1curl -s http://localhost:11434/api/show -d '{"model":"gemma4:e4b"}' | jq .

 1from langchain_core.rate_limiters import InMemoryRateLimiter
 2
 3rate_limiter = InMemoryRateLimiter(
 4    requests_per_second=0.1,  # 1 request every 10s
 5    check_every_n_seconds=0.1,  # Check every 100ms whether allowed to make a request
 6    max_bucket_size=1,  # Controls the maximum burst size.
 7)
 8
 9model = init_chat_model(
10    model="ollama:llama3.2:1b",
11    rate_limiter=rate_limiter  
12)
13
14question = "1+1? answer it as simple as you can"
15print(datetime.now(), model.invoke(question).content)
16print(datetime.now(), model.invoke(question).content)
17print(datetime.now(), model.invoke(question).content)
18print(datetime.now(), model.invoke(question).content)

12026-04-16 13:31:01.987762 2.
22026-04-16 13:31:12.222312 2.
32026-04-16 13:31:22.233443 2
42026-04-16 13:31:32.247292 2.

12026-04-16 13:33:33.147593 2.
22026-04-16 13:33:35.451476 2.
32026-04-16 13:33:37.492235 2.
42026-04-16 13:33:39.538332 2.

1model = init_chat_model(
2    model="ollama:llama3.2:1b",
3    base_url="http://192.168.86.55:11434"
4)

1model = init_chat_model(
2    model="MODEL_NAME",
3    model_provider="openai",
4    base_url="BASE_URL",
5    api_key="YOUR_API_KEY",
6)

1from langchain_openai import ChatOpenAI
2
3model = ChatOpenAI(
4    model="gpt-4.1",
5    openai_proxy="http://proxy.example.com:8080"
6)

1model = init_chat_model(
2    model="ollama:gemma4:e4b",
3    reasoning = False,
4).bind(logprobs=True)
5
6response = model.invoke("what's your model name")
7print(response.content)
8print(response.response_metadata)

 1from langchain.chat_models import init_chat_model
 2from langchain_core.callbacks import UsageMetadataCallbackHandler, get_usage_metadata_callback
 3
 4callback = UsageMetadataCallbackHandler()
 5
 6model = init_chat_model(
 7    model="ollama:gemma4:e4b",
 8    base_url='http://192.168.86.54:11434',
 9)
10
11result_1 = model.invoke("hello", config={"callbacks": [callback]})
12print(callback.usage_metadata)
13
14with get_usage_metadata_callback() as cb:
15    model.invoke("Hello")
16    model.invoke("Hello")
17    print(cb.usage_metadata)

1{'gemma4:e4b': {'input_tokens': 17, 'output_tokens': 210, 'total_tokens': 227}}
2{'gemma4:e4b': {'total_tokens': 319, 'input_tokens': 34, 'output_tokens': 285}}

1response = model.invoke("hello")
2print(response.response_metadata)

1<start_of_turn>user
2hello<end_of_turn>
3<start_of_turn>model

 1response = model.invoke(
 2    "Tell me a joke",
 3    config={
 4        "run_name": "joke_generation",      # Custom name for this run
 5        "tags": ["humor", "demo"],          # Tags for categorization
 6        "metadata": {"user_id": "123"},     # Custom metadata
 7        "callbacks": [my_callback_handler], # Callback handlers
 8        "model": "gpt-5-nano"               # Configure model
 9    }
10)

 1first_model = init_chat_model(
 2        model="gpt-4.1-mini",
 3        temperature=0,
 4        configurable_fields=("model", "temperature", "max_tokens"),
 5        config_prefix="first",  # Useful when you have a chain with multiple models
 6)
 7
 8first_model.invoke(
 9    "what's your name",
10    config={
11        "configurable": {
12            "first_temperature": 0.5,
13            "first_max_tokens": 100,
14        }
15    },
16)