旧教程在 LangChain v1 跑不通？新旧写法对照与报错速查

"""Try the import lines old tutorials use, and the new lines that replace them, in the installed environment."""
import re
import warnings
 
# (old import, new import) pairs. Every statement is executed for real in each environment.
PAIRS = [
    ("from langchain.chains import LLMChain", "from langchain_classic.chains import LLMChain"),
    ("from langchain.chains import RetrievalQA", "from langchain_classic.chains import RetrievalQA"),
    ("from langchain.chains import ConversationChain", "from langchain_classic.chains import ConversationChain"),
    ("from langchain.agents import initialize_agent, AgentType", "from langchain_classic.agents import initialize_agent, AgentType"),
    ("from langchain.agents import AgentExecutor", "from langchain_classic.agents import AgentExecutor"),
    ("from langchain.memory import ConversationBufferMemory", "from langchain_classic.memory import ConversationBufferMemory"),
    ("from langchain.prompts import PromptTemplate", "from langchain_core.prompts import PromptTemplate"),
    ("from langchain.schema import HumanMessage", "from langchain_core.messages import HumanMessage"),
    ("from langchain.schema import StrOutputParser", "from langchain_core.output_parsers import StrOutputParser"),
    ("from langchain.chat_models import ChatOpenAI", "from langchain_openai import ChatOpenAI"),
    ("from langchain.llms import OpenAI", "from langchain_openai import OpenAI"),
    ("from langchain.embeddings import OpenAIEmbeddings", "from langchain_openai import OpenAIEmbeddings"),
    ("from langchain.vectorstores import FAISS", "from langchain_community.vectorstores import FAISS"),
    ("from langchain.document_loaders import TextLoader", "from langchain_community.document_loaders import TextLoader"),
    ("from langchain.text_splitter import RecursiveCharacterTextSplitter", "from langchain_text_splitters import RecursiveCharacterTextSplitter"),
    ("from langchain.callbacks import StdOutCallbackHandler", "from langchain_core.callbacks import StdOutCallbackHandler"),
]
 
 
def clean(text: str, lines: int = 1) -> str:
    kept = [re.sub(r" \(/[^)]*\)", " (<path>)", s.strip()) for s in text.strip().splitlines() if s.strip()]
    return " / ".join(kept[:lines])[:240]
 
 
def attempt(statement: str):
    """Return (status, deprecation hints) for one import statement."""
    with warnings.catch_warnings(record=True) as caught:
        warnings.simplefilter("always")
        try:
            exec(statement, {})
            status = "OK"
        except BaseException as exc:  # noqa: BLE001 - the point is to show any failure
            status = f"{type(exc).__name__}: {clean(str(exc))}"
    hints = []
    for w in caught:
        # Old releases name the replacement import inside the deprecation message; keep only that.
        suggestion = re.search(r"from langchain_community[\w.]* import \w+", str(w.message))
        text = f"{w.category.__name__}, suggests: {suggestion.group(0)}" if suggestion else w.category.__name__
        if text not in hints:
            hints.append(text)
    return status, hints
 
 
for old, new in PAIRS:
    print(old)
    status, hints = attempt(old)
    print(f"    old: {status}")
    for hint in hints:
        print(f"    old warning: {hint}")
    status, _ = attempt(new)
    print(f"    new: {status}  <- {new.split(' import ')[0].replace('from ', '')}")

from langchain.chains import LLMChain
    old: OK
    new: ModuleNotFoundError: No module named 'langchain_classic'  <- langchain_classic.chains
from langchain.chains import RetrievalQA
    old: OK
    new: ModuleNotFoundError: No module named 'langchain_classic'  <- langchain_classic.chains
from langchain.chains import ConversationChain
    old: OK
    new: ModuleNotFoundError: No module named 'langchain_classic'  <- langchain_classic.chains
from langchain.agents import initialize_agent, AgentType
    old: OK
    new: ModuleNotFoundError: No module named 'langchain_classic'  <- langchain_classic.agents
from langchain.agents import AgentExecutor
    old: OK
    new: ModuleNotFoundError: No module named 'langchain_classic'  <- langchain_classic.agents
from langchain.memory import ConversationBufferMemory
    old: OK
    new: ModuleNotFoundError: No module named 'langchain_classic'  <- langchain_classic.memory
from langchain.prompts import PromptTemplate
    old: OK
    new: OK  <- langchain_core.prompts
from langchain.schema import HumanMessage
    old: OK
    new: OK  <- langchain_core.messages
from langchain.schema import StrOutputParser
    old: OK
    new: OK  <- langchain_core.output_parsers
from langchain.chat_models import ChatOpenAI
    old: OK
    old warning: LangChainDeprecationWarning, suggests: from langchain_community.chat_models import ChatOpenAI
    new: ModuleNotFoundError: No module named 'langchain_openai'  <- langchain_openai
from langchain.llms import OpenAI
    old: OK
    old warning: LangChainDeprecationWarning, suggests: from langchain_community.llms import OpenAI
    new: ModuleNotFoundError: No module named 'langchain_openai'  <- langchain_openai
from langchain.embeddings import OpenAIEmbeddings
    old: OK
    old warning: LangChainDeprecationWarning, suggests: from langchain_community.embeddings import OpenAIEmbeddings
    new: ModuleNotFoundError: No module named 'langchain_openai'  <- langchain_openai
from langchain.vectorstores import FAISS
    old: OK
    old warning: LangChainDeprecationWarning, suggests: from langchain_community.vectorstores import FAISS
    new: OK  <- langchain_community.vectorstores
from langchain.document_loaders import TextLoader
    old: OK
    old warning: LangChainDeprecationWarning, suggests: from langchain_community.document_loaders import TextLoader
    new: OK  <- langchain_community.document_loaders
from langchain.text_splitter import RecursiveCharacterTextSplitter
    old: OK
    new: OK  <- langchain_text_splitters
from langchain.callbacks import StdOutCallbackHandler
    old: OK
    new: OK  <- langchain_core.callbacks

from langchain.chains import LLMChain
    old: ModuleNotFoundError: No module named 'langchain.chains'
    new: ModuleNotFoundError: No module named 'langchain_classic'  <- langchain_classic.chains
from langchain.chains import RetrievalQA
    old: ModuleNotFoundError: No module named 'langchain.chains'
    new: ModuleNotFoundError: No module named 'langchain_classic'  <- langchain_classic.chains
from langchain.chains import ConversationChain
    old: ModuleNotFoundError: No module named 'langchain.chains'
    new: ModuleNotFoundError: No module named 'langchain_classic'  <- langchain_classic.chains
from langchain.agents import initialize_agent, AgentType
    old: ImportError: cannot import name 'initialize_agent' from 'langchain.agents' (<path>)
    new: ModuleNotFoundError: No module named 'langchain_classic'  <- langchain_classic.agents
from langchain.agents import AgentExecutor
    old: ImportError: cannot import name 'AgentExecutor' from 'langchain.agents' (<path>)
    new: ModuleNotFoundError: No module named 'langchain_classic'  <- langchain_classic.agents
from langchain.memory import ConversationBufferMemory
    old: ModuleNotFoundError: No module named 'langchain.memory'
    new: ModuleNotFoundError: No module named 'langchain_classic'  <- langchain_classic.memory
from langchain.prompts import PromptTemplate
    old: ModuleNotFoundError: No module named 'langchain.prompts'
    new: OK  <- langchain_core.prompts
from langchain.schema import HumanMessage
    old: ModuleNotFoundError: No module named 'langchain.schema'
    new: OK  <- langchain_core.messages
from langchain.schema import StrOutputParser
    old: ModuleNotFoundError: No module named 'langchain.schema'
    new: OK  <- langchain_core.output_parsers
from langchain.chat_models import ChatOpenAI
    old: ImportError: cannot import name 'ChatOpenAI' from 'langchain.chat_models' (<path>)
    new: OK  <- langchain_openai
from langchain.llms import OpenAI
    old: ModuleNotFoundError: No module named 'langchain.llms'
    new: OK  <- langchain_openai
from langchain.embeddings import OpenAIEmbeddings
    old: ImportError: cannot import name 'OpenAIEmbeddings' from 'langchain.embeddings' (<path>)
    new: OK  <- langchain_openai
from langchain.vectorstores import FAISS
    old: ModuleNotFoundError: No module named 'langchain.vectorstores'
    new: ModuleNotFoundError: No module named 'langchain_community'  <- langchain_community.vectorstores
from langchain.document_loaders import TextLoader
    old: ModuleNotFoundError: No module named 'langchain.document_loaders'
    new: ModuleNotFoundError: No module named 'langchain_community'  <- langchain_community.document_loaders
from langchain.text_splitter import RecursiveCharacterTextSplitter
    old: ModuleNotFoundError: No module named 'langchain.text_splitter'
    new: ModuleNotFoundError: No module named 'langchain_text_splitters'  <- langchain_text_splitters
from langchain.callbacks import StdOutCallbackHandler
    old: ModuleNotFoundError: No module named 'langchain.callbacks'
    new: OK  <- langchain_core.callbacks

"""Run the call styles old tutorials use against a minimal chat model and report what each one does."""
import re
import warnings
 
from langchain_core.language_models.chat_models import BaseChatModel
from langchain_core.messages import AIMessage, HumanMessage
from langchain_core.outputs import ChatGeneration, ChatResult
from langchain_core.prompts import PromptTemplate
 
 
class Pong(BaseChatModel):
    """A chat model that always answers 'pong'; no network, no API key."""
 
    @property
    def _llm_type(self) -> str:
        return "pong"
 
    def _generate(self, messages, stop=None, run_manager=None, **kwargs):
        return ChatResult(generations=[ChatGeneration(message=AIMessage(content="pong"))])
 
 
def clean(text: str, lines: int = 1) -> str:
    kept = [re.sub(r" \(/[^)]*\)", " (<path>)", s.strip()) for s in text.strip().splitlines() if s.strip()]
    return " / ".join(kept[:lines])[:240]
 
 
def case(label: str, fn) -> None:
    print(label)
    with warnings.catch_warnings(record=True) as caught:
        warnings.simplefilter("always")
        try:
            out = fn()
            print(f"    result: {out.content if isinstance(out, AIMessage) else out!r}")
        except BaseException as exc:  # noqa: BLE001 - the point is to show any failure
            print(f"    {type(exc).__name__}: {clean(str(exc))}")
    seen = []
    for w in caught:
        text = f"{w.category.__name__}: {clean(str(w.message))}"
        if text not in seen:
            seen.append(text)
            print(f"    warning {text}")
 
 
model = Pong()
case('model([HumanMessage("hi")])', lambda: model([HumanMessage(content="hi")]))
case('model.predict("hi")', lambda: model.predict("hi"))
case('model.predict_messages([HumanMessage("hi")])', lambda: model.predict_messages([HumanMessage(content="hi")]))
case('model.invoke("hi")', lambda: model.invoke("hi"))
 
try:
    from langchain.chains import LLMChain
    source = "langchain.chains"
except ImportError:
    try:
        from langchain_classic.chains import LLMChain
        source = "langchain_classic.chains"
    except ImportError:
        LLMChain = None
        source = "not installed"
print(f"LLMChain comes from: {source}")
 
if LLMChain is not None:
    prompt = PromptTemplate.from_template("Say {word}")
    chain = lambda: LLMChain(llm=model, prompt=prompt)  # noqa: E731 - a fresh chain per case
    case('chain.run("ping")', lambda: chain().run("ping"))
    case('chain({"word": "ping"})', lambda: chain()({"word": "ping"}))
    case('chain.predict(word="ping")', lambda: chain().predict(word="ping"))
    case('chain.invoke({"word": "ping"})', lambda: chain().invoke({"word": "ping"}))
 
try:
    from langchain_openai import ChatOpenAI
except ImportError as exc:
    print(f"langchain_openai: {type(exc).__name__}")
else:
    def old_style():
        llm = ChatOpenAI(model_name="gpt-4o-mini", openai_api_key="sk-demo", temperature=0, max_tokens=64)
        return (llm.model_name, llm.temperature, llm.max_tokens)
 
    case('ChatOpenAI(model_name=..., openai_api_key=..., temperature=0, max_tokens=64)', old_style)
    case('ChatOpenAI(model="gpt-4o-mini", api_key="sk-demo")', lambda: ChatOpenAI(model="gpt-4o-mini", api_key="sk-demo").model_name)
    case('ChatOpenAI(model="gpt-4o-mini") without any key', lambda: ChatOpenAI(model="gpt-4o-mini"))

model([HumanMessage("hi")])
    result: 'pong'
    warning LangChainDeprecationWarning: The method `BaseChatModel.__call__` was deprecated in langchain-core 0.1.7 and will be removed in 1.0. Use :meth:`~invoke` instead.
model.predict("hi")
    result: 'pong'
    warning LangChainDeprecationWarning: The method `BaseChatModel.predict` was deprecated in langchain-core 0.1.7 and will be removed in 1.0. Use :meth:`~invoke` instead.
model.predict_messages([HumanMessage("hi")])
    result: 'pong'
    warning LangChainDeprecationWarning: The method `BaseChatModel.predict_messages` was deprecated in langchain-core 0.1.7 and will be removed in 1.0. Use :meth:`~invoke` instead.
model.invoke("hi")
    result: 'pong'
LLMChain comes from: langchain.chains
chain.run("ping")
    result: 'pong'
    warning LangChainDeprecationWarning: The class `LLMChain` was deprecated in LangChain 0.1.17 and will be removed in 1.0. Use :meth:`~RunnableSequence, e.g., `prompt | llm`` instead.
    warning LangChainDeprecationWarning: The method `Chain.run` was deprecated in langchain 0.1.0 and will be removed in 1.0. Use :meth:`~invoke` instead.
chain({"word": "ping"})
    result: {'word': 'ping', 'text': 'pong'}
    warning LangChainDeprecationWarning: The method `Chain.__call__` was deprecated in langchain 0.1.0 and will be removed in 1.0. Use :meth:`~invoke` instead.
chain.predict(word="ping")
    result: 'pong'
chain.invoke({"word": "ping"})
    result: {'word': 'ping', 'text': 'pong'}
langchain_openai: ModuleNotFoundError

model([HumanMessage("hi")])
    TypeError: 'Pong' object is not callable
model.predict("hi")
    AttributeError: 'Pong' object has no attribute 'predict'
model.predict_messages([HumanMessage("hi")])
    AttributeError: 'Pong' object has no attribute 'predict_messages'
model.invoke("hi")
    result: 'pong'
LLMChain comes from: langchain_classic.chains
chain.run("ping")
    result: 'pong'
    warning LangChainDeprecationWarning: The class `LLMChain` was deprecated in LangChain 0.1.17 and will be removed in 2.0.0. Use `RunnableSequence, e.g., `prompt | llm`` instead.
    warning LangChainDeprecationWarning: The method `Chain.run` was deprecated in langchain-classic 0.1.0 and will be removed in 2.0.0. Use `invoke` instead.
chain({"word": "ping"})
    result: {'word': 'ping', 'text': 'pong'}
    warning LangChainDeprecationWarning: The method `Chain.__call__` was deprecated in langchain-classic 0.1.0 and will be removed in 2.0.0. Use `invoke` instead.
chain.predict(word="ping")
    result: 'pong'
chain.invoke({"word": "ping"})
    result: {'word': 'ping', 'text': 'pong'}
ChatOpenAI(model_name=..., openai_api_key=..., temperature=0, max_tokens=64)
    result: ('gpt-4o-mini', 0.0, 64)
ChatOpenAI(model="gpt-4o-mini", api_key="sk-demo")
    result: 'gpt-4o-mini'
ChatOpenAI(model="gpt-4o-mini") without any key
    OpenAIError: Missing credentials. Please pass an `api_key`, `workload_identity`, `admin_api_key`, or set the `OPENAI_API_KEY` or `OPENAI_ADMIN_KEY` environment variable.