An Overview of LangChain: Architecture, Core Components, and Code Examples

LangChain is an open‑source AI engineering framework built on large language models (LLMs). It helps researchers and developers quickly prototype, experiment with, and deploy NLP‑centric applications by providing reusable components, tools, and integrations (e.g., Hugging Face).

Technical Architecture

LangChain library – Python and JavaScript SDKs that expose interfaces for composing components, ready‑made chains, and agents.

LangChain templates – reference architectures for common tasks.

LangServe – a library that turns LangChain chains into REST APIs.

LangSmith – a development platform for debugging, testing, evaluating, and monitoring chains built with any LLM framework.

Core abstractions (six major concepts)

Models : support for chat models (message‑based APIs) and standard LLMs such as ChatGPT.

Embeddings : convert text into vector representations for downstream processing.

Prompts : prompt templates that simplify deployment of reusable prompts.

Indexes : vector databases and interaction‑layer prompts for information retrieval.

Memory : external knowledge sources and tools that enable stateful interactions.

Chains : composable pipelines built with the LangChain Expression Language (LCEL) that connect components.

Agents : LLM‑driven decision makers that can call tools or APIs autonomously.

Usage examples

1. Direct RESTful call to OpenAI’s Chat Completion API:

import os
import requests

# API Key
api_key = os.getenv('OPENAI_API_KEY')

# Headers
headers = {
    'Content-Type': 'application/json',
    'Authorization': f'Bearer {api_key}'
}

# Payload
data = {
    'model': 'gpt-4',
    'messages': [{'role': 'user', 'content': '什么是图计算？'}],
    'temperature': 0.7
}

# Request
url = 'https://api.openai.com/v1/chat/completions'
response = requests.post(url, json=data, headers=headers)
answer = response.json()['choices'][0]['message']['content']
print(answer)

2. Using the LangChain OpenAI SDK:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model_name='gpt-4')
response = llm.invoke('什么是图计算？')
print(response)

IO abstraction

LangChain provides Prompt and OutputParser abstractions to handle input formatting and output parsing, reducing repetitive text‑processing code.

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

llm = ChatOpenAI(model_name='gpt-4')
prompt = ChatPromptTemplate.from_template('{question}')
output_parser = StrOutputParser()

message = prompt.invoke({'question': '什么是图计算？'})
response = llm.invoke(message)
answer = output_parser.invoke(response)
print(answer)

LCEL (LangChain Expression Language)

LCEL overloads the __or__ operator to create Unix‑style pipelines, enabling concise chain definitions:

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

llm = ChatOpenAI(model_name='g4')
prompt = ChatPromptTemplate.from_template('{question}')
output_parser = StrOutputParser()

chain = prompt | llm | output_parser
answer = chain.invoke({'question': '什么是图计算？'})
print(answer)

RunnablePassthrough

Allows upstream parameters to be passed through a chain without explicit handling:

from langchain_core.runnables import RunnablePassthrough

chain = {"question": RunnablePassthrough()} | prompt | llm | output_parser
answer = chain.invoke('什么是图计算？')
print(answer)

DAG (Directed Acyclic Graph) example

from operator import itemgetter
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model_name='gpt-4')
output_parser = StrOutputParser()

topic_prompt = ChatPromptTemplate.from_template("生成一种'{input}'的名称")
good_prompt = ChatPromptTemplate.from_template('列举{topic}的好处:')
bad_prompt = ChatPromptTemplate.from_template('列举{topic}的坏处:')
summary_prompt = ChatPromptTemplate.from_messages([
    ("ai", "{topic}"),
    ("human", "好处:\n{good}\n\n坏处:\n{bad}"),
    ("system", "生成最终结论")
])

topic_chain = topic_prompt | llm | output_parser | {"topic": RunnablePassthrough()}
goods_chain = good_prompt | llm | output_parser
bads_chain = bad_prompt | llm | output_parser
summary_chain = summary_prompt | llm | output_parser

chain = (
    topic_chain |
    {"good": goods_chain, "bad": bads_chain, "topic": itemgetter("topic")} |
    summary_chain
)
answer = chain.invoke({"input": '常见水果'})
print(answer)

LangSmith

LangSmith is a monitoring and evaluation platform that integrates seamlessly with LangChain, providing debugging, testing, and performance tracking for any LLM‑based workflow.

LangGraph

LangGraph extends LangChain by supporting cyclic and multi‑chain computation graphs, enabling more complex autonomous agent applications.

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
from langgraph.graph import END, MessageGraph

model = ChatOpenAI(temperature=0)
graph = MessageGraph()
graph.add_node("oracle", model)
graph.add_edge("oracle", END)
graph.set_entry_point("oracle")

runnable = graph.compile()
result = runnable.invoke(HumanMessage("What is 1 + 1?"))
print(result)

Memory

Memory components store conversation history or external knowledge, allowing LLMs to maintain context across turns.

RAG (Retrieval‑Augmented Generation)

RAG combines vector‑store retrieval with LLM prompting to mitigate hallucinations and provide up‑to‑date, domain‑specific answers.

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores.faiss import FAISS
from langchain_core.documents import Document
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import OpenAIEmbeddings, ChatOpenAI

llm = ChatOpenAI(model_name='gpt-4')
prompt = ChatPromptTemplate.from_template('基于上下文：{context}\n回答：{input}')
output_parser = StrOutputParser()

docs = [Document(page_content='TuGraph是蚂蚁开源的图数据库产品')]
splits = RecursiveCharacterTextSplitter().split_documents(docs)
vector_store = FAISS.from_documents(splits, OpenAIEmbeddings())
retriever = vector_store.as_retriever()

chain_no_context = RunnablePassthrough() | llm | output_parser
chain = ({"context": retriever, "input": RunnablePassthrough()} | prompt | llm | output_parser)
print(chain_no_context.invoke('蚂蚁图数据库开源了吗？'))
print(chain.invoke('蚂蚁图数据库开源了吗？'))

Tools

Tools let LLMs invoke external functions (e.g., weather APIs) via the OpenAI function‑calling interface.

from openai import OpenAI
import json

client = OpenAI()

def get_current_weather(location, unit="fahrenheit"):
    """Get the current weather in a given location"""
    if "tokyo" in location.lower():
        return json.dumps({"location": "Tokyo", "temperature": "10", "unit": unit})
    elif "san francisco" in location.lower():
        return json.dumps({"location": "San Francisco", "temperature": "72", "unit": unit})
    elif "paris" in location.lower():
        return json.dumps({"location": "Paris", "temperature": "22", "unit": unit})
    else:
        return json.dumps({"location": location, "temperature": "unknown"})

messages = [{"role": "user", "content": "What's the weather like in San Francisco, Tokyo, and Paris?"}]
tools = [{"type": "function", "function": {"name": "get_current_weather", "description": "Get the current weather in a given location", "parameters": {"type": "object", "properties": {"location": {"type": "string", "description": "The city and state, e.g. San Francisco, CA"}, "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}}, "required": ["location"]}}}]
response = client.chat.completions.create(model="gpt-3.5-turbo-0125", messages=messages, tools=tools, tool_choice="auto")
print(response)

LangChain also provides a higher‑level tool‑binding API that automatically parses tool outputs:

from langchain_core.output_parsers.openai_tools import JsonOutputToolsParser
from langchain_core.runnables import RunnablePassthrough
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
import random

@tool
def get_temperature(city: str) -> int:
    """获取指定城市的当前气温"""
    return random.randint(-20, 50)

llm = ChatOpenAI(model_name='gpt-4')
output_parser = JsonOutputToolsParser()
chain = RunnablePassthrough() | llm.bind_tools(tools=[get_temperature]) | output_parser
print(chain.invoke('杭州今天多少度？'))

Agents

Agents use LLMs as reasoning engines to decide which actions (including tool calls) to take, enabling autonomous workflows.

from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder, HumanMessagePromptTemplate, SystemMessagePromptTemplate
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
import random

llm = ChatOpenAI()

@tool
def get_temperature(city: str) -> int:
    return random.randint(-20, 50)

tools = [get_temperature]
prompt = ChatPromptTemplate.from_messages([
    SystemMessagePromptTemplate.from_template('You are a helpful assistant'),
    MessagesPlaceholder(variable_name='chat_history', optional=True),
    HumanMessagePromptTemplate.from_template('{input}'),
    MessagesPlaceholder(variable_name='agent_scratchpad')
])

agent = create_openai_tools_agent(llm, tools, prompt=prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
print(agent_executor.invoke({'input': '今天杭州多少度？'})['output'])

Overall, LangChain offers a comprehensive toolbox that abstracts LLM interaction, prompt management, memory, retrieval, tool integration, and autonomous agents, allowing developers to focus on application logic rather than low‑level API handling.