Ecosystem & Packages

from importlib.metadata import requires
import re

for dist in ("langchain", "langgraph", "deepagents", "langchain-classic", "langchain-ollama"):
    deps = sorted({re.split(r"[ <>=!;\[]", r)[0] for r in requires(dist) or []
                   if "extra ==" not in r
                   and re.split(r"[ <>=!;\[]", r)[0].startswith(("langchain", "langgraph", "langsmith", "deepagents"))})
    print(f"{dist:18} requires {deps}")

langchain          requires ['langchain-core', 'langgraph']
langgraph          requires ['langchain-core', 'langgraph-checkpoint', 'langgraph-prebuilt', 'langgraph-sdk']
deepagents         requires ['langchain', 'langchain-anthropic', 'langchain-core', 'langchain-google-genai', 'langsmith']
langchain-classic  requires ['langchain-core', 'langchain-text-splitters', 'langsmith']
langchain-ollama   requires ['langchain-core']

uv add langchain langchain-ollama langgraph langsmith
# or, without uv:
python -m pip install -U langchain langchain-ollama

from langchain.chat_models import init_chat_model
from langchain.embeddings import init_embeddings

chat = init_chat_model("ollama:llama3.1:8b", temperature=0)
emb = init_embeddings("ollama:nomic-embed-text")
print(type(chat).__module__, type(chat).__name__, chat.model)
print(type(emb).__module__, type(emb).__name__)

langchain_ollama.chat_models ChatOllama llama3.1:8b
langchain_ollama.embeddings OllamaEmbeddings

from deepagents import create_deep_agent
from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
from langchain_core.messages import AIMessage


class FakeToolModel(GenericFakeChatModel):
    """GenericFakeChatModel that tolerates bind_tools(); it never actually calls a tool."""

    def bind_tools(self, tools, **kwargs):
        return self


model = FakeToolModel(messages=iter([AIMessage("Deep agent is wired up.")]))
agent = create_deep_agent(model=model, system_prompt="You are DocsAssistant.")
out = agent.invoke({"messages": [{"role": "user", "content": "hi"}]})
print(out["messages"][-1].content)

Deep agent is wired up.

import importlib


def resolves(module: str, name: str) -> str:
    try:
        getattr(importlib.import_module(module), name)
        return "ok"
    except (ImportError, AttributeError):
        return "missing"


CHECKS = [
    ("langchain_classic.chains", "LLMChain"),
    ("langchain_classic.retrievers", "MultiQueryRetriever"),
    ("langchain_classic.retrievers", "MultiVectorRetriever"),
    ("langchain_classic.retrievers.self_query.base", "SelfQueryRetriever"),
    ("langchain_classic.indexes", "SQLRecordManager"),
    ("langchain_classic.chains", "create_sql_query_chain"),
    ("langchain_core.indexing", "index"),
    ("langchain_text_splitters", "RecursiveCharacterTextSplitter"),
    ("langchain.agents", "create_agent"),
    ("langgraph.prebuilt", "create_react_agent"),
    ("pydantic", "BaseModel"),
    ("langchain.chains", "LLMChain"),
    ("langchain.retrievers", "MultiQueryRetriever"),
    ("langchain.text_splitter", "RecursiveCharacterTextSplitter"),
    ("langchain_core.pydantic_v1", "BaseModel"),
]
for module, name in CHECKS:
    print(f"{resolves(module, name):8} from {module} import {name}")

from langchain_classic import hub
print("ok       from langchain_classic import hub ->", hub.__name__)

ok       from langchain_classic.chains import LLMChain
ok       from langchain_classic.retrievers import MultiQueryRetriever
ok       from langchain_classic.retrievers import MultiVectorRetriever
ok       from langchain_classic.retrievers.self_query.base import SelfQueryRetriever
ok       from langchain_classic.indexes import SQLRecordManager
ok       from langchain_classic.chains import create_sql_query_chain
ok       from langchain_core.indexing import index
ok       from langchain_text_splitters import RecursiveCharacterTextSplitter
ok       from langchain.agents import create_agent
ok       from langgraph.prebuilt import create_react_agent
ok       from pydantic import BaseModel
missing  from langchain.chains import LLMChain
missing  from langchain.retrievers import MultiQueryRetriever
missing  from langchain.text_splitter import RecursiveCharacterTextSplitter
missing  from langchain_core.pydantic_v1 import BaseModel
ok       from langchain_classic import hub -> langchain_classic.hub

uv venv --python 3.12 .venv
uv pip install --python .venv/bin/python -U langchain langchain-ollama langchain-classic langsmith
.venv/bin/python smoke.py

"""Install smoke test: versions, import paths, and one tiny end-to-end run with a fake model."""
from importlib.metadata import version

# Which distributions are installed, and at which version?
for dist in ("langchain", "langchain-core", "langchain-classic", "langchain-text-splitters",
             "langgraph", "langsmith", "langchain-ollama"):
    print(f"{dist:26} {version(dist)}")

# The v1 import paths resolve, and the removed ones really are gone.
from langchain.agents import create_agent                                  # langchain
from langchain.chat_models import init_chat_model                          # langchain
from langchain.tools import tool                                           # re-exported from core
from langchain_core.messages import AIMessage, HumanMessage                # langchain-core
from langchain_text_splitters import RecursiveCharacterTextSplitter        # langchain-text-splitters
from langchain_classic.chains import LLMChain                              # langchain-classic
from langchain_ollama import ChatOllama, OllamaEmbeddings                  # partner package
from langgraph.graph import StateGraph, START, END                         # langgraph
from langsmith import traceable                                            # langsmith

try:
    import langchain.chains  # noqa: F401
except ModuleNotFoundError as e:
    print("langchain.chains ->", e)

# One agent run, no network: a fake chat model answers.
from langchain_core.language_models.fake_chat_models import GenericFakeChatModel

model = GenericFakeChatModel(messages=iter([AIMessage("pgvector is a PostgreSQL extension for vector search.")]))
agent = create_agent(model=model, tools=[], system_prompt="You are DocsAssistant.")
result = agent.invoke({"messages": [HumanMessage("What is pgvector?")]})
print([type(m).__name__ for m in result["messages"]])
print(result["messages"][-1].content)

# A two-node LangGraph graph, to prove langgraph itself is wired up.
from typing import TypedDict


class State(TypedDict):
    text: str


def shout(state: State) -> State:
    return {"text": state["text"].upper()}


g = StateGraph(State)
g.add_node("shout", shout)
g.add_edge(START, "shout")
g.add_edge("shout", END)
print(g.compile().invoke({"text": "ok"}))

langchain                  1.4.3
langchain-core             1.6.5
langchain-classic          1.0.8
langchain-text-splitters   1.1.2
langgraph                  1.2.12
langsmith                  0.14.1
langchain-ollama           1.1.0
langchain.chains -> No module named 'langchain.chains'
['HumanMessage', 'AIMessage']
pgvector is a PostgreSQL extension for vector search.
{'text': 'OK'}