langchain-experimental

langchain-experimental is the incubator package for the LangChain ecosystem — the place new agent patterns, reasoning strategies, and integrations land before (or instead of) being promoted into langchain-core or langchain-community. It ships implementations that are useful in practice but not yet stable enough, or too narrow in scope, to belong in the core library: Tree of Thought reasoning, AutoGPT- and BabyAGI-style autonomous agents, natural-language-to-SQL and natural-language-to-Cypher chains, PAL (Program-Aided Language models) math and logic chains, data anonymization utilities built on Presidio, and LLM-backed graph transformers for building knowledge graphs from unstructured text.

Because the code here is explicitly labeled experimental, the maintainers are candid that some modules execute LLM-generated code (Python, Bash, SQL) with real side effects, and the README carries a standing warning that this should only run inside a sandboxed environment. That trade-off is the point of the package: it lets teams try research-grade agent techniques against a stable LangChain interface without waiting for them to be hardened, then either keep using them as-is or graduate the pattern into their own code once it proves out.

As of mid-2026 the maintainers have announced langchain-experimental is being sunset (tracked in issue #87 on the repo), with no further active feature development — existing modules remain installable and usable, but new experimental work is expected to land elsewhere in the LangChain ecosystem going forward. Teams already depending on modules like the graph transformers or SQL chains can keep using pinned versions, but should plan a migration path for new projects.

What You Get

• Tree of Thought (ToT) chain — a checker/controller/thought-generation pipeline for multi-path LLM reasoning over problems like the Sudoku-style constraint puzzles in the package’s own tests
• Autonomous agent implementations — AutoGPT- and BabyAGI-style agent loops, plus a HuggingGPT-inspired multi-model task orchestrator
• Natural-language database chains — SQLDatabaseChain and a vector-SQL variant for turning plain-English questions into SQL, plus LLM graph transformers that extract nodes/relationships from text into GraphDocument objects for graph databases
• PAL (Program-Aided Language models) chains — math and logic problem solving where the LLM writes and the chain executes intermediate code rather than reasoning purely in natural language
• Data anonymization tooling — Presidio-based PII detection, anonymization, and reversible de-anonymization with configurable matching strategies
• Prompt injection identifiers and moderation utilities — including an Amazon Comprehend-backed content moderation chain for filtering unsafe LLM inputs/outputs

Common Use Cases

• Prototyping an agent architecture (AutoGPT/BabyAGI-style planning loops) before committing to a custom implementation
• Letting non-technical users query a SQL or graph database in plain English via an LLM-generated query chain
• Building a knowledge graph from unstructured documents using the LLM graph transformer, then loading it into Neo4j or another graph store
• Anonymizing PII in text passed to an LLM API and reversibly de-anonymizing the response for compliance-sensitive workflows
• Exploring Tree-of-Thought or PAL-style reasoning chains for problems where single-pass chain-of-thought prompting underperforms

Under The Hood

Architecture The package is organized as a flat collection of largely independent LangChain “integration” modules — agents, autonomous_agents, graph_transformers, sql, tot, pal_chain, data_anonymizer, and about a dozen others — each implementing LangChain’s standard Chain/Runnable interfaces from langchain_core rather than inventing its own execution model. There is no shared internal framework beyond that base class contract: langchain_experimental/tot/base.py composes a ThoughtGenerationStrategy, a Checker, and a Controller into a single ToTChain, while langchain_experimental/graph_transformers/llm.py drives an LLMGraphTransformer through a JsonOutputParser and a few-shot ChatPromptTemplate to turn Document text into GraphDocument node/relationship objects. Because every module only depends on langchain-core’s Runnable abstraction, removing or breaking any one module (e.g. sql/) has no effect on the others — the coupling is deliberately shallow, which fits the package’s role as a grab-bag of independently graduated-or-abandoned experiments rather than a cohesive application.

Tech Stack Pure Python (99.7% of the codebase), targeting Python 3.10+, built with the pdm-backend build system per pyproject.toml. Runtime dependencies are pinned to langchain-core (>=1.4.0,<2.0.0) and langchain-community (>=0.4.2,<1.0.0), with heavier integrations — langchain-classic, langchain-openai, langchain-text-splitters — pulled in only as dev/test/typing dependency-group extras via git references rather than runtime requirements, keeping the installed footprint of the base package small. Presidio powers the data-anonymizer module, and Pydantic is used throughout for structured LLM output parsing (e.g. the create_model-based schema construction in the graph transformer). Linting is ruff, typing is mypy in strict mode (disallow_untyped_defs), and CI is GitHub Actions with dedicated lint/test/compile-integration-test/codespell workflows.

Code Quality The repo has a real unit_tests/integration_tests split, with unit tests covering agents, chat_models, rl_chain, and core chains like SQL and PAL, plus a mock/fake LLM harness for testing without live API calls — a materially more thorough setup than a typical experimental grab-bag. mypy strict mode and ruff are both enforced in CI (_lint.yml, and a dedicated _test.yml), and pytest is configured with --strict-markers --strict-config, which fails the suite on any unregistered marker or config typo rather than silently ignoring it. Naming and typing conventions are consistent with the wider LangChain monorepo. The main caveat is that quality standards are uneven across modules by design — this is explicitly experimental code, and the package’s own __init__.py now emits a DeprecationWarning on import stating it is being sunset and is no longer actively maintained.

What Makes It Unique What’s distinctive isn’t any single algorithm — Tree of Thought, PAL, and AutoGPT-style loops all originate from published research the package translates into LangChain-native chains — but the packaging strategy: it gives research techniques a stable, installable interface against langchain-core immediately, without forcing them through the review bar of the core library first. That let LangChain users adopt cutting-edge agent patterns years before frameworks like LangGraph matured, at the acknowledged cost of running LLM-generated code (Python/Bash/SQL execution chains) with real side effects, which the README repeatedly and explicitly flags as something to sandbox. Its now-announced sunset is itself informative: it marks the maturation of the ecosystem, as most of these experimental patterns have either graduated into langchain-community/langchain-core or been superseded by purpose-built agent frameworks.