Langchain Architecture

# 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
res