AI Engineering Academy · บทเรียน

สถาปัตยกรรม LangChain และนามธรรมหลัก

ทำความเข้าใจโมเดลส่วนประกอบของ LangChain ซึ่งรวมถึง LLM, ChatModels, PromptTemplates, OutputParsers และ Runnables รวมถึงวิธีประกอบส่วนเหล่านี้เป็นกระบวนการ

สถาปัตยกรรม LangChain และนามธรรมหลัก เป็นบทเรียน AI Engineering Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน AI Engineering Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส AI Engineering Academy มีบทเรียนทั้งหมด 4 บทเรียน

LangChain คืออะไรในความเป็นจริง

LangChain คือกรอบการทำงานสำหรับสร้างแอปพลิเคชันที่ขับเคลื่อนด้วยโมเดลภาษา แทนที่จะเขียนการเรียกเอพีไอและโค้ดเชื่อมต่อเอง LangChain มีส่วนประกอบที่นำกลับมาใช้ใหม่ได้และนำมาต่อเข้าด้วยกันเป็นกระบวนการได้ รองรับผู้ให้บริการ LLM หลายราย (OpenAI, Anthropic, Cohere และโมเดลภายในเครื่อง) ผ่านส่วนติดต่อที่เป็นหนึ่งเดียว ทำให้การเปลี่ยนผู้ให้บริการต้องแก้ไขโค้ดเพียงเล็กน้อย

ภาพรวมรูปแบบส่วนประกอบ

LangChain จัดกลุ่มองค์ประกอบพื้นฐานสำหรับสร้างระบบเป็นหมวดหมู่ส่วนประกอบที่แตกต่างกัน LLM และ ChatModels ทำหน้าที่ห่อหุ้มผู้ให้บริการโมเดล PromptTemplates จัดการการสร้างคำสั่งแบบไดนามิก OutputParsers แปลงข้อความดิบจากโมเดลให้เป็นออบเจ็กต์ Python ที่มีโครงสร้าง และ Runnables คือส่วนติดต่อสากลที่เชื่อมทุกอย่างเข้าด้วยกันเป็นกระบวนการที่ประกอบรวมได้

LLM กับ ChatModels

LangChain แบ่งอินเทอร์เฟซของโมเดลออกเป็นสองแบบ LLM รับพรอมต์แบบสตริงและส่งคืนผลลัพธ์แบบสตริง ซึ่งเป็นรูปแบบการเติมข้อความแบบเก่า ส่วน ChatModel รับรายการข้อความ (ระบบ ผู้ใช้ และ AI) แล้วส่งคืนออบเจ็กต์ข้อความ โมเดลสมัยใหม่ของ OpenAI, Anthropic และ Gemini ล้วนเป็น ChatModels สำหรับแอปพลิเคชันใหม่ ควรเลือกใช้ ChatModel

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage

llm = ChatOpenAI(model='gpt-4o-mini')
response = llm.invoke([
    SystemMessage(content='You are a helpful assistant.'),
    HumanMessage(content='What is LangChain?')
])
print(response.content)

PromptTemplates: พรอมต์แบบไดนามิก

PromptTemplate ช่วยให้คุณกำหนดพรอมต์ที่มีตัวแปรตัวแทน ซึ่งจะถูกเติมค่าเมื่อโปรแกรมทำงาน ส่วน ChatPromptTemplate ทำงานแบบเดียวกันกับพรอมต์รูปแบบแชตที่มีหลายข้อความ เทมเพลตช่วยแยกโครงสร้างพรอมต์ออกจากค่าในขณะทำงาน ทำให้สามารถนำพรอมต์กลับมาใช้ใหม่ ทดสอบ และจัดการเวอร์ชันได้ง่าย

from langchain_core.prompts import ChatPromptTemplate

template = ChatPromptTemplate.from_messages([
    ('system', 'You are an expert in {domain}.'),
    ('human', 'Explain {concept} in simple terms.')
])

# Fill in variables at runtime
messages = template.invoke({'domain': 'machine learning', 'concept': 'embeddings'})
print(messages)

OutputParsers: การจัดรูปแบบผลลัพธ์ของโมเดล

OutputParsers แปลงผลลัพธ์สตริงดิบจากโมเดลให้เป็นชนิดข้อมูล Python ที่มีโครงสร้าง StrOutputParser แยกสตริงเนื้อหาออกมาโดยตรง JsonOutputParser แยกวิเคราะห์ JSON ส่วน PydanticOutputParser ตรวจสอบข้อมูลตามสคีมา Pydantic นอกจากนี้ ตัวแยกวิเคราะห์ยังสร้างคำแนะนำรูปแบบที่คุณแทรกลงในพรอมต์ เพื่อชี้นำโมเดลให้ส่งผลลัพธ์ในรูปแบบที่คาดไว้ได้

from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
from pydantic import BaseModel

class MovieReview(BaseModel):
    title: str
    rating: int
    summary: str

parser = JsonOutputParser(pydantic_object=MovieReview)
# parser.get_format_instructions() returns JSON schema instructions
print(parser.get_format_instructions()[:200])

อินเทอร์เฟซ Runnable

ทุกองค์ประกอบของ LangChain ใช้อินเทอร์เฟซ Runnable ซึ่งกำหนดเมธอดสำคัญสามรายการ ได้แก่ invoke() สำหรับการเรียกครั้งเดียวแบบทำงานพร้อมกัน stream() สำหรับส่งข้อมูลแบบสตรีมทีละโทเค็น และ batch() สำหรับประมวลผลอินพุตหลายรายการพร้อมกัน เนื่องจากทุกองค์ประกอบเป็น Runnable จึงสามารถนำมาประกอบใช้งานในรูปแบบเดียวกันด้วยตัวดำเนินการไปป์

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model='gpt-4o-mini')

# Single call
result = llm.invoke('What is 2+2?')

# Streaming tokens
for chunk in llm.stream('Tell me a joke.'):
    print(chunk.content, end='', flush=True)

# Batch processing
results = llm.batch(['What is Paris?', 'What is Rome?'])

การประกอบด้วยตัวดำเนินการไปป์

ตัวดำเนินการไปป์ (|) เป็นไวยากรณ์ย่อสำหรับสร้างออบเจ็กต์ RunnableSequence เมื่อคุณเขียน prompt | llm | parser LangChain จะสร้างสายงานที่ส่งผลลัพธ์ของแต่ละขั้นไปยังอินพุตของขั้นถัดไป นี่คือแกนหลักของ LCEL — LangChain Expression Language — และเข้ามาแทนที่คลาสสายงานแบบเดิมที่มีรายละเอียดมาก

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

prompt = ChatPromptTemplate.from_template('Summarize this in one sentence: {text}')
llm = ChatOpenAI(model='gpt-4o-mini')
parser = StrOutputParser()

# Chain composed with pipe operator
chain = prompt | llm | parser

result = chain.invoke({'text': 'LangChain is a framework for LLM applications...'})
print(result)

ตัวโหลดเอกสารและตัวแบ่งข้อความ

สำหรับแอปพลิเคชัน RAG, LangChain มี ตัวโหลดเอกสาร ที่อ่านไฟล์ในรูปแบบต่าง ๆ (PDF, Word, HTML, CSV) และส่งคืนรายการออบเจ็กต์ Document ซึ่งมีฟิลด์ page_content และ metadata จากนั้น ตัวแบ่งข้อความ จะแบ่งเอกสารยาวออกเป็นส่วนย่อยที่เหมาะสำหรับการสร้างเวกเตอร์ฝังตัวและการค้นคืน

from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

loader = PyPDFLoader('report.pdf')
docs = loader.load()  # List of Document objects

splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)
chunks = splitter.split_documents(docs)
print(f'Split {len(docs)} pages into {len(chunks)} chunks')

Vector Stores ในฐานะ Runnable

LangChain ห่อหุ้มฐานข้อมูลเวกเตอร์ (Chroma, Pinecone, pgvector) เป็นออบเจ็กต์ VectorStore ที่มีเมธอด similarity_search() คุณสามารถแปลง VectorStore ใด ๆ ให้เป็น Runnable ประเภท ตัวค้นคืน ด้วย .as_retriever() ทำให้สามารถนำไปประกอบในสายงาน LCEL ได้ ตัวค้นคืนรับสตริงคำค้นและส่งคืนเอกสารที่เกี่ยวข้องมากที่สุดจำนวน k รายการ

from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma

embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)

# Convert to Retriever Runnable
retriever = vectorstore.as_retriever(
    search_type='similarity',
    search_kwargs={'k': 5}
)

results = retriever.invoke('How does LangChain work?')
for doc in results:
    print(doc.page_content[:100])

การเรียกกลับและการสังเกตการทำงาน

ระบบการเรียกกลับของ LangChain ช่วยให้คุณเชื่อมต่อกับทุกเหตุการณ์ระหว่างการทำงานของสายงานได้ เช่น เมื่อ LLM เริ่มทำงาน เมื่อมีการสตรีมโทเค็น เมื่อสายงานทำงานเสร็จ และเมื่อมีการเรียกใช้เครื่องมือ การเรียกกลับที่มีมาให้ประกอบด้วย StdOutCallbackHandler สำหรับบันทึกข้อมูลลงคอนโซล การผสานการทำงานจากผู้ให้บริการภายนอก เช่น LangSmith จะเชื่อมต่อโดยอัตโนมัติผ่านตัวแปรสภาพแวดล้อม และบันทึกลำดับการทำงานทั้งหมดโดยไม่ต้องแก้ไขโค้ด

from langchain.callbacks import StdOutCallbackHandler
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model='gpt-4o-mini',
    callbacks=[StdOutCallbackHandler()]
)
# Now every call logs input/output automatically

# Or enable LangSmith tracing globally:
import os
os.environ['LANGCHAIN_TRACING_V2'] = 'true'
os.environ['LANGCHAIN_API_KEY'] = 'your-key'

หน่วยความจำและสถานะในสายงาน

โดยค่าเริ่มต้น สายงานของ LangChain จะเป็นแบบ ไร้สถานะ กล่าวคือการเรียกใช้แต่ละครั้งเป็นอิสระต่อกัน หากต้องการเพิ่มหน่วยความจำสำหรับการสนทนา คุณสามารถห่อสายงานด้วยองค์ประกอบหน่วยความจำที่จัดเก็บและแทรกประวัติการสนทนาได้ RunnableWithMessageHistory คือวิธีแบบเนทีฟของ LCEL สำหรับเพิ่มหน่วยความจำ โดยรับฟังก์ชัน get_session_history ที่โหลดประวัติตาม ID ของเซสชัน

from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import ChatMessageHistory

store = {}  # session_id -> ChatMessageHistory

def get_session_history(session_id: str):
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

with_history = RunnableWithMessageHistory(chain, get_session_history)
response = with_history.invoke(
    {'input': 'Hi, my name is Alice'},
    config={'configurable': {'session_id': 'user-1'}}
)

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจของคุณเกี่ยวกับสถาปัตยกรรมและแนวคิดนามธรรมหลักของ LangChain

สรุปบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้ว่า โมเดลส่วนประกอบของ LangChain จัดระเบียบ LLM, PromptTemplates, OutputParsers และตัวค้นคืนให้เป็น Runnable ที่มีอินเทอร์เฟซแบบเดียวกัน ตัวดำเนินการไปป์ (|) ใช้ประกอบ Runnable เป็นสายงานตามลำดับผ่าน LCEL และ การเรียกกลับ ช่วยให้สังเกตการทำงานได้ในทุกขั้นโดยไม่ต้องเปลี่ยนตรรกะทางธุรกิจ บทถัดไปเราจะลงลึกเกี่ยวกับการสร้างสายงานด้วย LCEL

คำถามที่พบบ่อย

บทเรียน “สถาปัตยกรรม LangChain และนามธรรมหลัก” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “สถาปัตยกรรม LangChain และนามธรรมหลัก” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส AI Engineering Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส AI Engineering Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “สถาปัตยกรรม LangChain และนามธรรมหลัก”

ทำความเข้าใจโมเดลส่วนประกอบของ LangChain ซึ่งรวมถึง LLM, ChatModels, PromptTemplates, OutputParsers และ Runnables รวมถึงวิธีประกอบส่วนเหล่านี้เป็นกระบวนการ คุณปฏิบัติ AI Engineering Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน AI Engineering Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน AI Engineering Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “สถาปัตยกรรม LangChain และนามธรรมหลัก” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน AI Engineering Academy นี้ได้ไหม

ได้ บทเรียน AI Engineering Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ AI Engineering Academy