langchain-core

Provides a unified Runnable abstraction that enables declarative chaining of LLM components (models, prompts, tools, retrievers) through operator overloading and pipe syntax. LCEL compiles chains into optimized execution graphs with automatic batching, streaming, and async support. The pattern uses Python's __or__ operator to create composable pipelines that decouple component logic from orchestration, enabling both synchronous and asynchronous execution paths with identical code.

Defines BaseLanguageModel and ChatModel abstract base classes that normalize API differences across OpenAI, Anthropic, Groq, Ollama, and other LLM providers through a unified invoke/stream/batch interface. Each provider integration implements the same Runnable protocol, allowing chains to swap models without code changes. The abstraction handles token counting, model configuration (temperature, max_tokens), and response parsing through a consistent schema.

Provides RunnableConfig dataclass that enables fine-grained control over Runnable execution including callbacks, tags, metadata, recursion limits, and timeout settings. Config propagates through composed chains automatically, allowing global configuration of tracing, error handling, and resource limits without modifying chain code. Supports both context-based configuration (via context managers) and explicit parameter passing.

Enables batch and stream execution modes on any Runnable through batch() and stream() methods that automatically optimize execution strategy. Batch mode uses provider-specific batch APIs when available (e.g., OpenAI batch API) to reduce costs and latency. Stream mode returns async iterators that yield results incrementally, enabling real-time response handling. The system automatically selects the optimal execution path based on Runnable type and configuration.

Uses optional dependency pattern where core abstractions (BaseLanguageModel, BaseTool, BaseRetriever) are defined in langchain-core, while provider-specific implementations live in separate packages (langchain-openai, langchain-anthropic, etc.). This enables modular installation and prevents bloated dependencies. Integration packages implement the same Runnable interface, allowing seamless swapping. The system uses lazy imports and version pinning to ensure compatibility.

Provides a type hierarchy (BaseMessage, HumanMessage, AIMessage, SystemMessage, ToolMessage) that standardizes conversation history representation across providers. Supports multimodal content through ContentBlock unions that can contain text, images, tool calls, and tool results. The system uses Pydantic discriminated unions to ensure type safety and enable provider-specific serialization (e.g., OpenAI's image_url format vs Anthropic's base64 encoding).

Converts Python functions and Pydantic models into JSON Schema representations that LLM providers can use for function calling. The system uses Pydantic's schema generation to create provider-compatible schemas (OpenAI, Anthropic, Groq formats) with automatic docstring parsing for descriptions. BaseTool abstract class enables custom tool implementations with built-in error handling, argument validation, and async support through the Runnable interface.

Provides PromptTemplate and ChatPromptTemplate classes that enable parameterized prompt construction with variable substitution, type validation, and partial application. Templates use Jinja2-style syntax with Pydantic validation to ensure all required variables are provided before execution. The system integrates with the Runnable interface, allowing prompts to be composed with models and other components in chains.

Provides TextSplitter implementations (RecursiveCharacterTextSplitter, MarkdownHeaderTextSplitter, CodeTextSplitter) that break documents into chunks while preserving semantic boundaries and metadata. Splitters support configurable chunk size, overlap, and separator strategies. The system includes token counting integration to split by token count rather than character count, and preserves document metadata through chunk attribution.

Implements a BaseCallbackHandler interface that enables hooking into Runnable execution at multiple points (on_llm_start, on_chain_start, on_tool_end, etc.). Callbacks integrate with LangSmith for production tracing and debugging. The system supports both synchronous and asynchronous callbacks, allowing custom logging, monitoring, and debugging without modifying chain code. Callbacks are registered via RunnableConfig and propagate through composed chains automatically.

Provides OutputParser implementations (JsonOutputParser, PydanticOutputParser, XMLOutputParser) that convert LLM text responses into structured Python objects with validation. Parsers use Pydantic schemas to define expected output structure and validate responses before returning. The system includes retry logic to re-prompt the LLM if parsing fails, and supports both deterministic parsing (for models with structured output support) and heuristic parsing (for text-based responses).

Defines BaseRetriever abstract class that normalizes document retrieval across different backends (vector stores, BM25, hybrid search, web search). Retrievers implement the Runnable interface, enabling composition with LLM chains for retrieval-augmented generation (RAG). The system supports both synchronous and asynchronous retrieval, with configurable search parameters (top_k, similarity threshold) and metadata filtering.

Provides agent abstractions (AgentExecutor, agent creation utilities) that implement agentic loops combining LLM reasoning with tool execution. Agents use ReAct-style prompting to generate thoughts and tool calls, then execute tools and feed results back to the LLM. The system integrates with LangGraph for more complex agent patterns and supports custom agent logic through middleware. Built-in error handling, max iteration limits, and timeout controls prevent runaway execution.