Day 7: LangChain Full‑Map Overview and 6 Interview Questions

Full Architecture Diagram

┌────────────────────────────────────────────────────────────────────┐
│               LangChain Full‑Map Architecture                     │
│                                                                    │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │                     Model I/O Layer                         │   │
│  │  ChatModel / LLM ─── PromptTemplate ─── OutputParser          │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                     │                                            │
│  ┌───────────────────────────┴───────────────────────────────┐ │
│  │                     Chain / LCEL Layer                      │ │
│  │  LCEL: prompt | llm | parser  [legacy: LLMChain]           │ │
│  └──────────────────────────────────────────────────────────────┘ │
│                     │                                            │
│  ┌───────────────────────────┴───────────────────────────────┐ │
│  │                     Agent Layer (recommended: LangGraph) │ │
│  │  Agent ────── @tool                                      │ │
│  │  Legacy: create_react_agent()                             │ │
│  └──────────────────────────────────────────────────────────────┘ │
│                     │                                            │
│  ┌───────────────────────────┴───────────────────────────────┐ │
│  │                     Retrieval Layer                        │ │
│  │  DocumentLoader → Splitter → Embedding → VectorStore      │ │
│  └──────────────────────────────────────────────────────────────┘ │
│                     │                                            │
│  ┌───────────────────────────┴───────────────────────────────┐ │
│  │                     Memory Layer                           │ │
│  │  BufferMemory / SummaryMemory / ConversationSummary       │ │
│  └──────────────────────────────────────────────────────────────┘ │
└────────────────────────────────────────────────────────────────────┘

Core Module Quick Reference

Model I/O

ChatModel : ChatOpenAI(model="Pro/MiniMaxAI/MiniMax-M2.5") – chat interface.

LLM : OpenAI(model="Pro/MiniMaxAI/MiniMax-M2.5-mini") – text‑completion interface.

PromptTemplate : ChatPromptTemplate.from_messages() – message template.

OutputParser : JsonOutputParser / PydanticOutputParser – structured output.

Retrieval

DocumentLoader : PyPDFLoader / WebBaseLoader – loads documents.

TextSplitter : RecursiveCharacterTextSplitter – smart chunking.

Embedding : OpenAIEmbeddings – vectorization.

VectorStore : Chroma.from_documents() – stores vectors.

Chain / LCEL

LCEL pipeline : prompt | llm | parser – declarative chain composition.

RunnableParallel : RunnableParallel(a=chain1, b=chain2) – parallel execution.

RAG : retriever | (lambda docs: ...) | prompt | llm – LCEL‑based Retrieval‑Augmented Generation.

LCEL + Memory : memory + LCEL chain – multi‑turn conversation.

Agent / Tool

Custom Tool : @tool – decorates a function as a tool.

Agent (recommended) : create_agent(model, tools=[...], system_prompt=...) – built on LangGraph.

Tool Calling : llm.bind_tools() – structured tool invocation.

Legacy Agent : create_react_agent() – old API, not recommended.

Memory

BufferMemory : ConversationBufferMemory() – raw conversation storage.

SummaryBuffer : ConversationSummaryBufferMemory(max_token_limit) – automatic summarization when token limit is exceeded.

Callbacks : config={"callbacks": [handler]} – execution monitoring.

Competitor Comparison

Position : LangChain – all‑purpose framework; LlamaIndex – retrieval‑first; Haystack – QA‑focused.

RAG Support : LangChain – complete but heavyweight; LlamaIndex – optimized for RAG; Haystack – mature and stable.

Agent Capability : LangChain – strong; LlamaIndex – average; Haystack – average.

Learning Curve : LangChain – steep; LlamaIndex – medium; Haystack – gentle.

Ecosystem : LangChain – largest; LlamaIndex – medium; Haystack – smaller.

Suitable Scenarios : LangChain – complex LLM applications; LlamaIndex – deep RAG customization; Haystack – production‑grade QA systems.

Selection Recommendations

Complex Agent + RAG + multiple tools → LangChain

RAG‑centric knowledge‑base QA → LlamaIndex

Existing Elasticsearch, quick QA deployment → Haystack

Interview High‑Frequency Questions

Q1: Core advantages of LangChain

Unified Interface : The same API works for OpenAI, Claude, Ollama, etc., making model swaps cheap.

Modular Design : Six independent modules (Model, Prompt, Chain, Agent, Memory, Retrieval) can be combined as needed.

LCEL Expressions : Use the | pipeline operator to compose tasks; code doubles as documentation and benefits from lazy evaluation.

# Switch model without changing business code
llm = ChatOpenAI(model="Pro/MiniMaxAI/MiniMax-M2.5")
# llm = ChatAnthropic(model="claude-sonnet-4-6")

Q2: How RAG improves recall

Top‑K tuning : increase retrieved documents – k=5→10.

MMR diversity : avoid overly similar results – search_type="mmr".

Hybrid retrieval : combine keyword and vector search – EnsembleRetrieval.

Metadata filtering : restrict search scope – filter={"source": "pdf"}.

Reranking : recall first, then re‑rank – CohereRerank.

Chunk strategy : adjust chunk size and overlap – chunk_size=500, overlap=100.

Q3: Difference between Agent and Chain

Execution mode : Chain – fixed flow, declarative composition; Agent – dynamic decision‑making by the model.

Flexibility : Chain – medium (LCEL pipeline); Agent – high (model selects tools autonomously).

Applicable scenarios : Chain – clear pipelines (e.g., translate → summarize); Agent – complex tasks (search → judge → act).

Recommendation : LCEL is the preferred way for Chains; LangGraph is the recommended way for Agents.

Note : Use LCEL for simple pipelines ( prompt | llm | parser) and LangGraph for sophisticated Agent workflows ( create_agent).

Q4: Addressing LangChain token‑cost issue

Conversation Summary Memory : ConversationSummaryBufferMemory automatically summarizes when token limits are hit.

Streaming output : .stream() returns tokens as they are generated, reducing latency.

Prompt compression : remove unnecessary system‑prompt content.

Model downgrade : use a smaller model for simple tasks – e.g., ChatOpenAI(model="Pro/MiniMaxAI/MiniMax-M2.5-mini") (cost reduced ~20×).

# Simple task automatic downgrade
llm = ChatOpenAI(model="Pro/MiniMaxAI/MiniMax-M2.5-mini")  # Cost reduced ~20×

Q5: LCEL vs Traditional Chain

Syntax : Traditional – .run() / .apply() method calls; LCEL – pipeline operator |.

Evaluation : Traditional – immediate; LCEL – lazy, on‑demand.

Interface uniformity : Traditional – different per Chain; LCEL – unified Runnable interface.

Parallelism : Traditional – manual handling; LCEL – native support via RunnableParallel.

Debugging : Traditional – harder; LCEL – each step’s result is traceable.

# LCEL: declarative, code is documentation
chain = prompt | llm | parser
# Traditional Chain: imperative
chain = LLMChain(prompt=prompt, llm=llm)
result = chain.run(question)

Q6: What is Tool Calling and when to use it?

Tool Calling is the native function‑calling capability of models like GPT‑4 or Claude 3.5.

How it works :

The model analyses user intent and selects a tool to call.

The tool executes and returns its result to the model.

The model generates the final answer.

Typical scenarios :

Structured data extraction – extract JSON from free‑form text.

External system operation – check weather, search flights, place orders.

Multi‑step tasks – research assistant: search → organize → save.

Real‑time information query – lookup stock price, exchange rate, inventory.

Compared with ReAct, Tool Calling is more efficient (single step), while ReAct offers finer‑grained reasoning.

7‑Day Review

Day 1 : Four main components – ChatOpenAI, PromptTemplate, create_agent; environment setup.

Day 2 : Model I/O – ChatPromptTemplate, JsonOutputParser; LLM invocation.

Day 3 : Retrieval – PyPDFLoader, RecursiveCharacterTextSplitter, Chroma; document vectorization.

Day 4 : Full‑chain RAG – LCEL RAG chain + memory; QA chatbot.

Day 5 : Agent + Tools – @tool, create_agent; research assistant.

Day 6 : Memory + Chain – ConversationSummaryBufferMemory with LCEL; multi‑turn dialogue.

Day 7 : Full‑map recap – component quick‑lookup + interview Q&A gap filling.

Advanced Learning Path

Ecosystem Tools

LangServe : deploy Chains as REST APIs.

LangSmith : observability platform for LLM apps (debugging, monitoring).

LangChain Expression Language : core composition syntax (already mastered).

langchain‑ai/ecosystem : official plugin ecosystem.

Deep‑Dive Directions

RAG Deepening : hybrid retrieval, reranking, query rewriting.

Agent Deepening : multi‑Agent collaboration, Agent memory design.

Performance Optimization : streaming output, token‑cost control.

Production Deployment : LangServe + Docker + Kubernetes.

Reference Links

LangChain official docs: https://python.langchain.com/docs/

LangChain GitHub: https://github.com/langchain-ai/langchain

LCEL full tutorial: https://python.langchain.com/docs/concepts/lcel/

LangSmith platform: https://smith.langchain.com/

LangServe deployment guide: https://python.langchain.com/docs/concepts/langserve/