langchain-community

Provides unified Python interfaces to 50+ language model providers (OpenAI, Anthropic, Cohere, HuggingFace, local Ollama, etc.) through a standardized BaseLanguageModel class hierarchy. Each provider integration wraps native API clients with LangChain's common interface, handling authentication, request formatting, streaming, and response parsing. Developers write once against the abstraction and swap providers by changing a single import or configuration parameter.

Provides standardized Python wrappers for 30+ vector databases and embedding stores (Pinecone, Weaviate, Milvus, FAISS, Chroma, Qdrant, etc.) through a BaseRetriever and VectorStore interface. Each connector handles vector indexing, similarity search, metadata filtering, and document retrieval. Integrations abstract away database-specific query syntax and index management, exposing a common add_documents() and similarity_search() API.

Provides a unified Embeddings interface for 20+ embedding model providers (OpenAI, Cohere, HuggingFace, local models via Ollama). Each integration wraps the native embedding API and handles batching, caching, and error handling. The framework supports both synchronous and asynchronous embedding calls. Embeddings are used for semantic search, similarity comparison, and clustering in downstream tasks.

Provides pre-built RAG components (RetrievalQA, RetrievalQAWithSourcesChain) that combine document retrieval with LLM generation. The framework handles document loading, embedding, vector store indexing, and retrieval-augmented prompting. RAG pipelines support multiple retrieval strategies (similarity search, MMR, ensemble) and can be customized via chain composition. Built-in chains handle source attribution and answer generation.

Provides SQL agent and chain components that translate natural language queries into SQL statements and execute them against databases. The framework handles database schema introspection, SQL generation via LLM, query execution, and result interpretation. Supports multiple databases (PostgreSQL, MySQL, SQLite, etc.) via SQLAlchemy. Agents can iteratively refine queries based on execution results and error messages.

Provides web search integrations (Google Search, Bing, DuckDuckGo, Tavily) that enable LLM applications to search the internet and retrieve current information. The framework handles search query formatting, result parsing, and integration with RAG pipelines. Search results can be used to augment LLM context or answer questions requiring real-time information. Supports both synchronous and asynchronous search.

Provides a schema-based function registry that converts Python function signatures into provider-specific tool/function calling formats (OpenAI's function_calling, Anthropic's tool_use, Claude's XML tools, etc.). The registry validates function schemas, handles parameter binding, and routes function calls back to Python callables. Developers define tools once using Python type hints and Pydantic models; the framework automatically generates provider-specific schemas and handles invocation.

Provides 50+ document loaders for ingesting data from diverse sources (PDFs, web pages, databases, cloud storage, APIs) and converts them into a unified Document abstraction with metadata. Paired with configurable text splitters (recursive character, semantic, token-aware) that chunk documents while preserving context and metadata. Loaders handle format parsing, encoding detection, and metadata extraction; splitters optimize chunk size for embedding and retrieval workflows.

Provides a declarative chain abstraction (Runnable interface) for composing LLM workflows as directed acyclic graphs of operations. Chains can be piped together (prompt → LLM → parser), parallelized, conditionally branched, or looped. The framework handles input/output type validation, error propagation, and streaming across chain steps. Built-in chains include LLMChain, RetrievalQA, and custom chains can be defined via composition or subclassing.

Provides a PromptTemplate abstraction for defining reusable prompt structures with variable placeholders, input validation, and output formatting. Templates support Jinja2-style variable substitution, conditional blocks, and partial application. The framework validates that all required variables are provided before rendering, and supports prompt composition (chaining templates together). Built-in templates for common patterns (QA, summarization, translation) are included.

Provides output parsers that convert unstructured LLM text responses into structured Python objects (Pydantic models, JSON, lists, etc.). Parsers handle common formats (JSON, YAML, CSV) and implement retry logic with prompt repair when parsing fails. The framework includes specialized parsers for common patterns (list extraction, key-value pairs, structured data). Parsers validate output against schemas and can auto-correct malformed responses.

Provides an Agent abstraction that implements agentic patterns (ReAct, tool-use loops) where LLMs iteratively decide which tools to call, observe results, and reason about next steps. The framework handles tool selection, argument binding, execution, and loop termination. Built-in agents include OpenAI Functions Agent, ReAct Agent, and custom agents can be defined via AgentExecutor. Agents support streaming, error recovery, and max-iteration limits.

Provides memory abstractions (ConversationMemory, BufferMemory, SummaryMemory, EntityMemory) that store and retrieve conversation history for multi-turn interactions. Memory types include simple buffers (all messages), summarization (compress old messages), entity tracking (extract and track entities), and vector-based retrieval (semantic memory). The framework handles memory loading, updating, and pruning to manage context window limits. Memory can be persisted to external stores (databases, files).

Provides a callback system that hooks into LLM calls, chain execution, and agent reasoning for observability and logging. Callbacks can be registered at multiple levels (LLM, chain, agent) and receive events (on_llm_start, on_chain_end, on_tool_error). The framework supports custom callbacks for metrics collection, logging, tracing, and debugging. Built-in callbacks integrate with observability platforms (LangSmith, Weights & Biases).