第 23 期 | 长历史上下文优化：Context Window 挤压战 (EN)

⏱ Est. reading time: 18 min Updated on 5/7/2026

🎯 Learning Objectives for This Episode

Hey there, future AI masters! Welcome to the first stop of the LangChain Full-Stack Masterclass. I know you're all eager to build something huge with AI, but hold your horses—Rome wasn't built in a day, and neither is an intelligent customer support copilot. In this episode, we'll lay the most solid foundation to help you:

  • Understand LangChain's core value and positioning: Why do we need this framework, and what pain points does it solve in LLM application development?
  • Master LangChain's fundamental building blocks: Deep dive into the three cornerstones: LLMs, PromptTemplates, and Output Parsers.
  • Build a minimal customer support response skeleton: Get your support copilot off the ground from "zero" to handle basic conversations.
  • Familiarize yourself with the basic LangChain development workflow: Paving the way for more complex and powerful feature iterations down the road.

Ready? Fasten your seatbelts, we're about to take off!

📖 Core Concepts Explained

Alright folks, let's start with some theory. Before diving into the code, we need to understand what exactly we're playing with and why LangChain is the ultimate "cheat code" for this game.

What is LangChain and Why Use It?

Simply put, LangChain is a framework for developing applications powered by Large Language Models (LLMs). You might ask, "Isn't it fine to just call the OpenAI API directly?" Sure it is! But as you start building complex LLM applications, you'll quickly realize that merely calling an API is far from enough.

Imagine your intelligent support copilot needs to:

  1. Receive user queries.
  2. Wrap the query into a clear instruction (Prompt), telling the LLM what role to play and what question to answer.
  3. Wait for the LLM's response.
  4. Transform the LLM's raw, potentially unstructured output into structured data that our system can understand and process.
  5. When necessary, invoke external tools, query knowledge bases, remember previous conversations, and so on.

If you manually concatenate strings, parse JSON, and manage state every single time, it becomes an absolute nightmare! Your code will turn into a plate of spaghetti—hard to maintain, let alone scale.

The core value of LangChain lies in:

  • Abstraction: It provides a unified interface for different LLMs (OpenAI, Anthropic, open-source models, etc.), allowing you to switch between them effortlessly.
  • Modularity: It decouples the various components of an LLM application (like models, prompts, output parsers, memory, tools, etc.) into independent modules.
  • Composability: This is the most crucial part! Like Lego bricks, you can chain these modules together to form complex logic chains, building powerful and scalable AI applications.

So, LangChain is essentially the "operating system" for LLM app development. It provides a complete set of tools and conventions, enabling you to build your AI empire efficiently and elegantly.

The Three Cornerstones of LangChain: LLMs, Prompts, and Output Parsers

In the LangChain universe, there are a few concepts you must engrave in your mind. They are the starting point for building everything:

  1. LLMs (Large Language Models) / ChatModels:

    • This is the "brain" of your application, responsible for understanding and generating text. LangChain provides the LLM class (for text completion) and the ChatModel class (for multi-turn conversations), which serve as abstraction layers for interacting with underlying large models.
    • You don't need to worry whether the underlying model is OpenAI's GPT-4 or Llama 2; LangChain smooths out the differences for you.

  2. PromptTemplates:

    • This is the "language" you use to communicate with the "brain". You can't just tell the LLM, "Check the order for me." You need to say: "You are a professional customer service agent. The user is asking about an order; please provide the tracking link and precautions."
    • PromptTemplate allows you to define a string template with placeholders, dynamically injecting user input, context information, etc., ensuring clear and consistent instructions every time you interact with the LLM. This is key to controlling the LLM's behavior!

  3. Output Parsers:

    • LLM outputs are usually free-form text. However, more often than not, we want structured data, like JSON, lists, or even specifically formatted dates.
    • The role of an OutputParser is to take the raw text output from the LLM and safely and reliably convert it into a structured format that your program can understand and use. This significantly enhances the robustness and usability of your LLM applications.

Now, let's use a simple flowchart to visualize how these three work together in our intelligent support copilot.

graph TD
    A[User Query: "Where is my order tracking info?"] --1. Receive Input--> B{PromptTemplate: Construct Instruction}
    B --2. Fill Template e.g., "User query is '...'"--> C[LLM: Large Language Model e.g., OpenAI GPT-3.5]
    C --3. Generate Text Response--> D[Raw LLM Output: "Sure, please provide your order number. You can check the tracking info on the official website's order details page."]
    D --4. Structured Parsing--> E{OutputParser: Optional - Extract Key Info or Format}
    E --5. Return Structured Result--> F[Support Copilot: Return to User or Proceed with Next Steps]

See that? From a simple user query to the final response from the support copilot, the underlying process involves a PromptTemplate guiding the LLM to generate content, which is then polished by an OutputParser. This is the magic of LangChain's core modules!

💻 Hands-on Coding (Application in the Support Copilot Project)

Alright, theory sounds cool, but we are practitioners! Now, let's turn these concepts into code and build the very first version of our intelligent support copilot.

Scenario: The Rookie Support Copilot

In this episode, our support copilot is still very "young". It has no external knowledge base and no memory. It's like a newly onboarded rookie agent, only able to answer questions based on the "training manual" (Prompt) you provide and its own "smarts" (LLM).

Goal: Enable our support copilot to provide a polite and preliminary response based on user queries.

Preparation: Installing Dependencies

First, ensure your development environment is ready. We need the LangChain library and the OpenAI library (or your chosen LLM provider).

pip install langchain-community langchain-openai python-dotenv

langchain-community contains many common integrations, langchain-openai is specifically for OpenAI models, and python-dotenv helps us manage API keys.

Environment Variable Configuration: Create a .env file in your project root directory and fill in your OpenAI API key:

OPENAI_API_KEY="sk-YOUR_OPENAI_API_KEY_HERE"

Note: Never hardcode your API keys into your code! Using environment variables is a best practice.

Code Implementation: Building Your First LLM Chain

We will use Python for the implementation.

import os
from dotenv import load_dotenv

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# 1. Load environment variables from .env file
load_dotenv()

# 2. Initialize the LLM model (e.g., OpenAI's GPT-3.5-turbo)
# The temperature parameter controls the creativity of the model. 0 means more deterministic and consistent output.
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0) # Can also be gpt-4, gpt-4o, etc.

# 3. Define the PromptTemplate: This is the "training manual" for our customer service copilot.
# We want it to act as a professional, clearly answering user questions.
prompt_template = ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个专业、友好、乐于助人的智能客服助手。请礼貌、准确、简洁地回答用户关于产品或服务的问题。如果无法回答，请告知用户将转接人工客服。"),
        ("user", "{user_question}")
    ]
)

# 4. (Optional) Define Output Parser: Converts the raw LLM output into our desired format.
# For this episode, we simply want a string output, so we use StrOutputParser.
output_parser = StrOutputParser()

# 5. Build the Chain: Connects the Prompt, LLM, and Output Parser.
# LangChain's pipe syntax ( | ) makes building Chains very intuitive and elegant.
customer_service_chain = prompt_template | llm | output_parser

# 6. Run our intelligent customer service copilot!
print("--- 智能客服小助手启动 ---")
print("请输入您的问题 (输入 '退出' 结束):")

while True:
    user_input = input("\n用户: ")
    if user_input.lower() == '退出':
        print("客服小助手: 感谢您的使用，再见！")
        break

    # Invoke the Chain to process user input
    try:
        response = customer_service_chain.invoke({"user_question": user_input})
        print(f"客服小助手: {response}")
    except Exception as e:
        print(f"客服小助手: 抱歉，处理您的问题时遇到了一点小麻烦。请稍后再试或联系人工客服。错误信息: {e}")

Code Walkthrough: The Magic Behind Every Step

  1. load_dotenv(): Ensures your API keys are securely loaded. This is foundational!
  2. ChatOpenAI(model="gpt-3.5-turbo", temperature=0):
    • We chose ChatOpenAI because it's better suited for multi-turn interaction scenarios like customer support conversations.
    • model="gpt-3.5-turbo": Specifies the model to use. You can opt for more powerful models like gpt-4 or gpt-4o based on your needs and budget.
    • temperature=0: This parameter is crucial! It controls the "randomness" or "creativity" of the LLM's output. For customer support scenarios, we generally want answers to be deterministic, consistent, and highly factual, rather than wildly imaginative. Therefore, setting it to 0 is a solid choice.
  3. ChatPromptTemplate.from_messages(...):
    • This is the "soul" of our support copilot! We define a message-based Prompt template using the from_messages method.
    • ("system", "..."): The system message, used to set the LLM's persona, behavior, and overall guidelines. This is the key to telling the LLM "who you are and what to do."
    • ("user", "{user_question}"): The user message. Here we use {user_question} as a placeholder. LangChain will automatically inject the user's actual input into it at runtime.
  4. StrOutputParser():
    • This is the simplest output parser. It merely returns the raw string output from the LLM exactly as is.
    • You might think this is useless? Don't worry, in upcoming lessons, we'll explore much more powerful parsers that can transform LLM outputs into JSON, Python objects, or even custom data structures!
  5. prompt_template | llm | output_parser:
    • This is LangChain's "Pipe" magic! It takes the output of prompt_template as the input for llm, and the output of llm as the input for output_parser, ultimately forming an end-to-end workflow.
    • This chaining syntax (Chain) perfectly embodies LangChain's powerful composability, making the code concise and expressive.
  6. customer_service_chain.invoke({"user_question": user_input}):
    • The core method to execute the Chain. We wrap the user input into a dictionary, where the key (user_question) must match the placeholder defined in the PromptTemplate.
    • The Chain automatically handles the entire process: filling the template, calling the LLM, parsing the output, and returning the final result.

Now, run this code, and your first intelligent support copilot is online! You can try asking it some questions to see how it responds.

Pitfalls & Best Practices

As a seasoned mentor, I have to sound the alarm and help you avoid the traps I once fell into.

  1. Prompt Engineering is an Art, and Even More a Science:

    • Pitfall: Thinking a Prompt is just casually writing a few sentences. The result? The LLM gives irrelevant answers or is too generic.
    • Solution: The Prompt is your "Bible" for communicating with the LLM. A good Prompt should include:
      • Persona: "You are a professional customer service agent."
      • Goal: "Answer user questions about products or services."
      • Constraints: "Be polite, accurate, and concise. Transfer to a human agent if unable to answer."
      • Format (Optional): e.g., "Please return the answer in JSON format." (We'll cover this later).
    • Golden Rule: Test frequently and iterate constantly. Tweaking the Prompt is often more effective than adjusting model parameters.

  2. API Key Management: Safety First!

    • Pitfall: Directly writing OPENAI_API_KEY = "sk-..." in your code and pushing it to GitHub.
    • Solution: Never, ever, ever (saying it three times because it's that important) hardcode sensitive information into your codebase. Using a .env file along with python-dotenv is the most basic security practice. In production environments, you should use key management services provided by cloud vendors.

  3. Model Selection and Cost Considerations:

    • Pitfall: Blindly using the most powerful model (like GPT-4o) right out of the gate, resulting in skyrocketing bills.
    • Solution: Different models have different capabilities and pricing.
      • gpt-3.5-turbo: The king of cost-effectiveness, more than enough for handling routine customer service queries.
      • gpt-4 / gpt-4o: Stronger reasoning capabilities and longer context windows, suitable for complex problems or scenarios requiring high-quality creative output.
      • Recommendation: Start with the cheapest model that meets your needs, and only consider upgrading when you hit a bottleneck.

  4. The Non-determinism of LLM Outputs:

    • Pitfall: Expecting the LLM to give the exact same answer every time, or strictly adhere to your desired output format without fail.
    • Solution: LLMs are inherently probabilistic models. Even with temperature=0, 100% determinism isn't guaranteed. Outputs might have subtle variations, and occasional "hallucinations" can occur.
      • Fix: Introduce an OutputParser to standardize the output, implement retry mechanisms, or emphasize the output format in the Prompt and perform post-processing validation. This is exactly why OutputParsers are so important!

  5. The Cold Start Problem:

    • Pitfall: Finding the response extremely slow on the first LLM call and assuming it's a code or network issue.
    • Solution: Most LLM APIs experience a "cold start" latency on the initial call because the model might need to be loaded into the GPU. Subsequent calls will be much faster. In production environments, consider implementing warmup mechanisms or using asynchronous calls.

📝 Episode Summary

Congratulations! In this episode, you've successfully taken your first step into learning LangChain. We have:

  • Understood LangChain's core value as an LLM app development framework: Abstraction, modularity, and composability.
  • Mastered the three cornerstones: LLMs (ChatOpenAI), PromptTemplates (ChatPromptTemplate), and Output Parsers (StrOutputParser).
  • Built a fundamental intelligent support copilot from scratch: It can provide preliminary answers based on your "training manual" and user queries.
  • Explored common "pitfalls" in development and learned how to cleverly avoid them.

While our support copilot is quite talkative now, it still suffers from "amnesia"—every question feels like a first encounter. It also doesn't know where our product manuals or FAQ lists are. Don't worry, this is exactly the core problem we'll tackle in the next episode!

In the next episode, we will dive deep into another core concept of LangChain—Memory—enabling our support copilot to remember previous conversations and achieve true multi-turn interactions. At the same time, we'll introduce Document Loaders, allowing it to learn from external knowledge bases!

Stay tuned for the exciting content in the next episode, and continue your AI exploration journey!