3. 构建你的第一个流式 CLI 聊天

mkdir langchain-chat
cd langchain-chat

# 创建虚拟环境
python -m venv venv
 
# 激活（macOS/Linux）
source venv/bin/activate
 
# 激活（Windows）
venv\Scripts\activate

pip install langchain-core==1.2.7 langchain-openai==1.1.7 python-dotenv

# test_install.py
try:
    from langchain_core.messages import HumanMessage
    from langchain_openai import ChatOpenAI
    print("✓ langchain-core: OK")
    print("✓ langchain-openai: OK")
    print("\n安装成功！")
except ImportError as e:
    print(f"✗ 导入失败: {e}")
    print("请确保你的虚拟环境已激活。")

python test_install.py

✓ langchain-core: OK
✓ langchain-openai: OK
 
安装成功！

# requirements.txt
langchain-core==1.2.7
langchain-openai==1.1.7
python-dotenv

pip install -r requirements.txt

langchain-chat/
├── venv/                 # 虚拟环境（不要提交到 git）
├── requirements.txt      # 依赖列表
└── test_install.py       # 安装验证脚本

# ❌ 千万不要这么做
llm = ChatOpenAI(api_key="sk-proj-abc123...")

# .env
OPENAI_API_KEY=sk-proj-your-actual-key-here

# .gitignore
venv/
__pycache__/
*.pyc
.env

langchain-chat/
├── venv/
├── .env                  # 你的 API Key（被 git 忽略）
├── .gitignore           # 包含：.env、venv/ 等
├── requirements.txt
└── test_install.py

# chat.py
import os
from dotenv import load_dotenv
 
# 加载 .env 文件
load_dotenv()
 
# 访问环境变量
api_key = os.environ.get("OPENAI_API_KEY")
 
if not api_key:
    raise ValueError("在环境中未找到 OPENAI_API_KEY")
 
print(f"已加载 API Key：{api_key[:8]}...")  # 只显示前 8 个字符

from langchain_openai import ChatOpenAI
 
load_dotenv()
 
# 这会自动使用 os.environ["OPENAI_API_KEY"]
llm = ChatOpenAI(model="gpt-4o-mini")

llm = ChatOpenAI(
    model="gpt-4o-mini",
    api_key=os.environ.get("OPENAI_API_KEY")
)

response = llm.invoke("写一篇关于 AI 的 500 字短文")
print(response.content)  # 等 20 秒，然后整篇文章一次性出现

for chunk in llm.stream("写一篇关于 AI 的 500 字短文"):
    print(chunk.content, end="", flush=True)  # token 在生成时逐步出现

# chat.py
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
 
def main():
    load_dotenv()
    llm = ChatOpenAI(model="gpt-4o-mini")
    
    print("聊天已开始。输入 'quit' 或 'exit' 结束。\n")
    
    while True:
        user_input = input("You: ")
        
        if user_input.lower() in ["quit", "exit"]:
            print("再见！")
            break
        
        print("Assistant: ", end="", flush=True)
        
        for chunk in llm.stream([HumanMessage(content=user_input)]):
            print(chunk.content, end="", flush=True)
        
        print("\n")
 
if __name__ == "__main__":
    main()

你: 法国的首都是什么？
助手: 巴黎。
你: 它的人口是多少？
助手: 我没有足够的上下文。你在问哪个城市？

python chat.py

聊天已开始。输入 'quit' 或 'exit' 结束。
 
You: LangChain 是什么？
Assistant: LangChain 是一个用于开发由语言模型驱动的应用的框架。它提供了提示词管理、链、代理和记忆等工具。
 
You: 给我一个简单示例
Assistant: 这里有一个基础示例：...
 
You: quit
再见！

for chunk in llm.stream([HumanMessage(content="Hello")]):
    print(f"Chunk: {chunk}")
    print(f"Content: {chunk.content}")
    print(f"Type: {type(chunk)}")

Chunk: content='Hello' response_metadata={'model_provider': 'openai', ...}
Content: Hello
Type: <class 'langchain_core.messages.ai.AIMessageChunk'>
 
Chunk: content='!' response_metadata={...}
Content: !
Type: <class 'langchain_core.messages.ai.AIMessageChunk'>
 
Chunk: content=' How' response_metadata={...}
Content:  How
Type: <class 'langchain_core.messages.ai.AIMessageChunk'>

def chat_with_accumulation():
    load_dotenv()
    llm = ChatOpenAI(model="gpt-4o-mini")
    
    user_input = input("你: ")
    
    full_response = ""
    print("助手: ", end="", flush=True)
    
    for chunk in llm.stream([HumanMessage(content=user_input)]):
        print(chunk.content, end="", flush=True)
        full_response += chunk.content
    
    print("\n")
    
    # 现在你已经拥有完整响应
    print(f"[DEBUG] 完整响应长度: {len(full_response)} 字符")
    return full_response

langchain-chat/
├── venv/
├── .env
├── .gitignore
├── requirements.txt
├── test_install.py
└── chat.py              # 流式聊天循环（新增！）

# Temperature 0.0 - 确定性强，每次答案都一样
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.0)
response = llm.invoke([HumanMessage(content="2+2 等于多少？")])
print(response.content)  # 输出: 4
 
# Temperature 1.0 - 默认行为，可能有轻微措辞变化
llm = ChatOpenAI(model="gpt-4o-mini", temperature=1.0)
response = llm.invoke([HumanMessage(content="2+2 等于多少？")])
print(response.content)  # 输出: 4（可能会带简短解释）

# ❌ 这会在 o3 模型上失败
llm = ChatOpenAI(model="o3-mini", temperature=0.7)

BadRequestError: Temperature is not supported with this model

# ❌ 聊天方式 - 对推理模型不适用
llm = ChatOpenAI(model="o3-mini", temperature=0.5)
# 错误: BadRequestError: Temperature is not supported
 
# ✅ 推理方式 - 通过提示词结构引导
prompt = """
逐步解决这个问题：
1. 说明你已知的信息
2. 展示你的计算过程
3. 验证你的答案
 
问题：如果 x + 5 = 12，x 等于多少？
"""
llm = ChatOpenAI(model="o3-mini")
response = llm.invoke([HumanMessage(content=prompt)])
print(response.content)

1. 我已知的信息：x + 5 = 12
2. 计算过程：x = 12 - 5 = 7
3. 验证：7 + 5 = 12 ✓
 
答案：x = 7

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
 
llm = ChatOpenAI(model="gpt-4o-mini")
response = llm.invoke([HumanMessage(content="Hello")])
 
# 响应里有什么？
print(type(response))  # AIMessage
print(response.content)  # 实际文本
print(response.response_metadata)  # token 用量、模型信息等

<class 'langchain_core.messages.ai.AIMessage'>
Hello! How can I assist you today?
{
  'token_usage': {
    'completion_tokens': 9,
    'prompt_tokens': 8,
    'total_tokens': 17
  },
  'model_name': 'gpt-4o-mini-2024-07-18',
  'finish_reason': 'stop',
  ...
}

token_usage = response.response_metadata['token_usage']
print(f"Prompt tokens: {token_usage['prompt_tokens']}")
print(f"Response tokens: {token_usage['completion_tokens']}")
print(f"Total: {token_usage['total_tokens']}")

Prompt tokens: 8
Response tokens: 9
Total: 17

def calculate_cost(token_usage, model_name):
    """根据 token 用量计算成本。"""
    prompt_tokens = token_usage.get('prompt_tokens', 0)
    completion_tokens = token_usage.get('completion_tokens', 0)
    
    # 每 100 万 token 的定价（截至 2026 年 1 月）
    pricing = {
        'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
        'gpt-4o': {'input': 2.50, 'output': 10.00},
        'gpt-5': {'input': 1.25, 'output': 10.00},
    }
    
    if model_name not in pricing:
        return None
    
    input_cost = (prompt_tokens / 1_000_000) * pricing[model_name]['input']
    output_cost = (completion_tokens / 1_000_000) * pricing[model_name]['output']
    
    return input_cost + output_cost
 
# 示例
response = llm.invoke([HumanMessage(content="Explain quantum computing")])
token_usage = response.response_metadata['token_usage']
cost = calculate_cost(token_usage, "gpt-4o-mini")
print(f"Cost: ${cost:.6f}")

Cost: $0.000123

from langchain_core.globals import set_debug
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
 
set_debug(True)
 
# 现在所有 LLM 调用都会打印调试信息
llm = ChatOpenAI(model="gpt-4o-mini")
response = llm.invoke([HumanMessage(content="Hello")])

[llm/start] [llm:ChatOpenAI] Entering LLM run with input:
{
  "prompts": [
    "Human: Hello"
  ]
}
[llm/end] [llm:ChatOpenAI] [1.45s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "Hello! How can I assist you today?",
        "generation_info": {
          "finish_reason": "stop",
          "logprobs": null
        },
        "type": "ChatGeneration",
        ...
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "completion_tokens": 9,
      "prompt_tokens": 8,
      "total_tokens": 17,
      ...
    },
    "model_provider": "openai",
    "model_name": "gpt-4o-mini-2024-07-18",
    ...
  },
}

# 你的代码
[HumanMessage(content="Hello")]
 
# 你在调试输出中看到的内容
{
  "prompts": ["Human: Hello"]
}

"finish_reason": "stop"

"token_usage": {
  "completion_tokens": 9,
  "prompt_tokens": 8,
  "total_tokens": 17,
  "completion_tokens_details": {
    "reasoning_tokens": 0  # 推理模型专用（o1/o3 等）
  },
  "prompt_tokens_details": {
    "cached_tokens": 0  # 提示词缓存（节省成本）
  }
}

"model_name": "gpt-4o-mini-2024-07-18",
"system_fingerprint": "fp_8bbc38b4db"

[llm/end] [llm:ChatOpenAI] [1.56s]

# .env 文件不存在，或 OPENAI_API_KEY 未定义
llm = ChatOpenAI(model="gpt-4o-mini")
response = llm.invoke([HumanMessage(content="Hello")])

OpenAIError: The api_key client option must be set either by passing api_key to the client or by setting the OPENAI_API_KEY environment variable

# .env 中是: OPENAI_API_KEY=sk-invalid-key-12345
llm = ChatOpenAI(model="gpt-4o-mini")
response = llm.invoke([HumanMessage(content="Hello")])

AuthenticationError: Incorrect API key provided

OPENAI_API_KEY=sk-proj-exactkeyhere

# 请求过程中 WiFi 断开，或 OpenAI API 宕机
response = llm.invoke([HumanMessage(content="Hello")])

APIConnectionError: Connection error

# 立即发送 1000 个请求
for i in range(1000):
    llm.invoke([HumanMessage(content=f"Request {i}")])

RateLimitError: Rate limit reached for requests

llm = ChatOpenAI(model="gpt-99-ultra")  # 不存在
response = llm.invoke([HumanMessage(content="Hello")])

NotFoundError: The model `gpt-99-ultra` does not exist or you do not have access to it

# 创建一个 100 万字符的提示词
huge_prompt = "x" * 1_000_000
response = llm.invoke([HumanMessage(content=huge_prompt)])

BadRequestError: This model's maximum context length is 128000 tokens. However, your messages resulted in 250000 tokens.