LangChain

LangChain provides a Chain abstraction that sequences LLM calls, prompt templates, and tool invocations into directed acyclic graphs (DAGs). Chains support sequential execution (SequentialChain), conditional branching (RouterChain), and parallel execution patterns. The framework uses a Runnable interface that standardizes input/output contracts across all chain components, enabling composition via pipe operators and method chaining. This allows developers to build complex multi-step workflows without managing state manually.

LangChain's PromptTemplate class provides structured prompt engineering with variable placeholders, automatic validation, and support for few-shot learning patterns. Templates use Jinja2-style syntax for variable substitution and support dynamic example selection via ExampleSelector. The framework includes specialized templates (ChatPromptTemplate for multi-turn conversations, FewShotPromptTemplate for in-context learning) that handle formatting differences across LLM types. This enables prompt reusability, version control, and systematic experimentation without string concatenation.

LangChain abstracts function calling across LLM providers by converting Python functions or Pydantic models into provider-specific schemas (OpenAI function_call, Anthropic tool_use, etc.). The framework automatically generates schemas, handles argument parsing, and routes calls to the correct provider. Developers define functions once and LangChain handles provider-specific formatting. This enables tool use without learning each provider's function calling API.

LangChain supports streaming LLM output at token granularity, enabling real-time user feedback as tokens are generated. The framework provides streaming iterators and async generators that yield tokens as they arrive from the LLM. Streaming is integrated into chains and agents, so developers can stream output from complex workflows without special handling. This enables responsive user experiences where output appears in real-time rather than waiting for full completion.

LangChain provides async/await support throughout the framework, enabling concurrent execution of LLM calls, chains, and agents. All major components (LLMs, chains, retrievers, agents) have async variants (e.g., arun() alongside run()). The framework uses asyncio for Python and native async/await for Node.js. This enables high-concurrency applications that can handle multiple requests simultaneously without blocking. Async execution is transparent; developers write the same code as sync but use async/await syntax.

LangChain abstracts LLM APIs behind a common BaseLanguageModel interface, supporting OpenAI, Anthropic, Cohere, Hugging Face, Ollama, and 20+ other providers. The abstraction handles provider-specific details: token counting, streaming, function calling schemas, and cost tracking. Developers write LLM-agnostic code and swap providers via configuration. The framework includes built-in retry logic, rate limiting, and fallback chains for reliability. This enables portability and cost optimization without rewriting application logic.

LangChain provides a Retriever abstraction that enables RAG by connecting LLMs to external knowledge sources. The framework supports multiple retrieval strategies: vector similarity search (via VectorStore), BM25 keyword search, hybrid search, and custom retrievers. Documents are chunked, embedded, and stored in vector databases (Pinecone, Weaviate, Chroma, FAISS, etc.). The RetrievalQA chain automatically retrieves relevant documents and passes them as context to the LLM. This enables LLMs to answer questions grounded in custom data without fine-tuning.

LangChain's Agent abstraction enables autonomous task execution by combining LLMs with tools (functions, APIs, retrievers). The agent uses an action-observation loop: the LLM decides which tool to call based on the task, executes the tool, observes the result, and repeats until the task is complete. Agents support multiple reasoning strategies: ReAct (reasoning + acting), chain-of-thought, and tool-use patterns. The framework handles tool schema generation, argument parsing, and error recovery. This enables building autonomous systems that can decompose complex tasks without explicit step-by-step instructions.

LangChain provides memory abstractions (ConversationMemory, ConversationSummaryMemory, ConversationBufferMemory) that manage conversation history and context across turns. Memory implementations handle token limits by summarizing old messages, implementing sliding windows, or extracting key facts. The framework integrates memory with chains and agents, automatically loading context before each LLM call and saving new messages after. This enables stateful conversations without manual history management or exceeding token limits.

LangChain's OutputParser abstraction converts unstructured LLM text into structured data (JSON, Pydantic models, lists, etc.). Parsers include JSONParser, PydanticOutputParser, CommaSeparatedListOutputParser, and custom parsers. The framework uses prompt engineering (few-shot examples, explicit formatting instructions) to guide LLMs toward parseable output. For models supporting structured output (OpenAI's JSON mode), parsers leverage native APIs. This enables reliable extraction of structured data from LLM responses without regex or manual parsing.

LangChain provides DocumentLoader implementations for 50+ file formats (PDF, HTML, Markdown, Word, CSV, JSON, code files, etc.) that extract text and metadata. The framework includes TextSplitter strategies (recursive character splitting, semantic chunking, token-aware splitting) that break documents into chunks optimized for embedding and retrieval. Loaders and splitters are composable: load documents, split into chunks, embed, and store in vector database. This eliminates boilerplate for document ingestion pipelines.

LangChain's Callback system enables developers to hook into LLM calls, chain execution, and agent reasoning at multiple points (start, end, error, streaming tokens). Callbacks are registered on chains and agents and receive events with context (input, output, latency, tokens used). Built-in callbacks include logging, LangSmith integration for tracing, and streaming output. Custom callbacks can implement monitoring, cost tracking, or custom business logic. This enables observability without modifying application code.

LangChain provides evaluation tools for assessing LLM application outputs against criteria like correctness, relevance, and safety. Evaluators use LLMs themselves (self-evaluation) or external metrics (BLEU, ROUGE, embedding similarity). The framework includes evaluators for Q&A (comparing answers to ground truth), summarization (comparing summaries to reference summaries), and custom criteria. Evaluations can be run on datasets and results aggregated. This enables systematic quality assessment without manual review.