LangChain Architecture

Master the LangChain framework for building sophisticated LLM applications with agents, chains, memory, and tool integration.

Do not use this skill when

• •The task is unrelated to langchain architecture
• •You need a different domain or tool outside this scope

Instructions

• •Clarify goals, constraints, and required inputs.
• •Apply relevant best practices and validate outcomes.
• •Provide actionable steps and verification.
• •If detailed examples are required, open resources/implementation-playbook.md.

Use this skill when

• •Building autonomous AI agents with tool access
• •Implementing complex multi-step LLM workflows
• •Managing conversation memory and state
• •Integrating LLMs with external data sources and APIs
• •Creating modular, reusable LLM application components
• •Implementing document processing pipelines
• •Building production-grade LLM applications

Core Concepts

1. Agents

Autonomous systems that use LLMs to decide which actions to take.

Agent Types:

• •ReAct: Reasoning + Acting in interleaved manner
• •OpenAI Functions: Leverages function calling API
• •Structured Chat: Handles multi-input tools
• •Conversational: Optimized for chat interfaces
• •Self-Ask with Search: Decomposes complex queries

2. Chains

Sequences of calls to LLMs or other utilities.

Chain Types:

• •LLMChain: Basic prompt + LLM combination
• •SequentialChain: Multiple chains in sequence
• •RouterChain: Routes inputs to specialized chains
• •TransformChain: Data transformations between steps
• •MapReduceChain: Parallel processing with aggregation

3. Memory

Systems for maintaining context across interactions.

Memory Types:

• •ConversationBufferMemory: Stores all messages
• •ConversationSummaryMemory: Summarizes older messages
• •ConversationBufferWindowMemory: Keeps last N messages
• •EntityMemory: Tracks information about entities
• •VectorStoreMemory: Semantic similarity retrieval

4. Document Processing

Loading, transforming, and storing documents for retrieval.

Components:

• •Document Loaders: Load from various sources
• •Text Splitters: Chunk documents intelligently
• •Vector Stores: Store and retrieve embeddings
• •Retrievers: Fetch relevant documents
• •Indexes: Organize documents for efficient access

5. Callbacks

Hooks for logging, monitoring, and debugging.

Use Cases:

• •Request/response logging
• •Token usage tracking
• •Latency monitoring
• •Error handling
• •Custom metrics collection

Quick Start

from langchain.agents import AgentType, initialize_agent, load_tools
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory

# Initialize LLM
llm = OpenAI(temperature=0)

# Load tools
tools = load_tools(["serpapi", "llm-math"], llm=llm)

# Add memory
memory = ConversationBufferMemory(memory_key="chat_history")

# Create agent
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memory,
    verbose=True
)

# Run agent
result = agent.run("What's the weather in SF? Then calculate 25 * 4")

Architecture Patterns

Pattern 1: RAG with LangChain

from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings

# Load and process documents
loader = TextLoader('documents.txt')
documents = loader.load()

text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
texts = text_splitter.split_documents(documents)

# Create vector store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)

# Create retrieval chain
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(),
    return_source_documents=True
)

# Query
result = qa_chain({"query": "What is the main topic?"})

Pattern 2: Custom Agent with Tools

from langchain.agents import Tool, AgentExecutor
from langchain.agents.react.base import ReActDocstoreAgent
from langchain.tools import tool

@tool
def search_database(query: str) -> str:
    """Search internal database for information."""
    # Your database search logic
    return f"Results for: {query}"

@tool
def send_email(recipient: str, content: str) -> str:
    """Send an email to specified recipient."""
    # Email sending logic
    return f"Email sent to {recipient}"

tools = [search_database, send_email]

agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

Pattern 3: Multi-Step Chain

from langchain.chains import LLMChain, SequentialChain
from langchain.prompts import PromptTemplate

# Step 1: Extract key information
extract_prompt = PromptTemplate(
    input_variables=["text"],
    templat