langchain 0.2.13__py3-none-any.whl → 0.2.15__py3-none-any.whl

langchain/agents/tools.py

@@ -6,7 +6,7 @@ from langchain_core.callbacks import (
     AsyncCallbackManagerForToolRun,
     CallbackManagerForToolRun,
 )
-from langchain_core.tools import BaseTool, Tool, tool
+from langchain_core.tools import BaseTool, tool
 
 
 class InvalidTool(BaseTool):
@@ -44,4 +44,4 @@ class InvalidTool(BaseTool):
         )
 
 
-__all__ = ["InvalidTool", "BaseTool", "tool", "Tool"]
+__all__ = ["InvalidTool", "tool"]

langchain/agents/xml/base.py

@@ -8,16 +8,16 @@ from langchain_core.prompts.base import BasePromptTemplate
 from langchain_core.prompts.chat import AIMessagePromptTemplate, ChatPromptTemplate
 from langchain_core.runnables import Runnable, RunnablePassthrough
 from langchain_core.tools import BaseTool
+from langchain_core.tools.render import ToolsRenderer, render_text_description
 
 from langchain.agents.agent import BaseSingleActionAgent
 from langchain.agents.format_scratchpad import format_xml
 from langchain.agents.output_parsers import XMLAgentOutputParser
 from langchain.agents.xml.prompt import agent_instructions
 from langchain.chains.llm import LLMChain
-from langchain.tools.render import ToolsRenderer, render_text_description
 
 
-@deprecated("0.1.0", alternative="create_xml_agent", removal="0.3.0")
+@deprecated("0.1.0", alternative="create_xml_agent", removal="1.0")
 class XMLAgent(BaseSingleActionAgent):
     """Agent that uses XML tags.
 

langchain/chains/base.py

@@ -334,7 +334,7 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
             None, self._call, inputs, run_manager.get_sync() if run_manager else None
         )
 
-    @deprecated("0.1.0", alternative="invoke", removal="0.3.0")
+    @deprecated("0.1.0", alternative="invoke", removal="1.0")
     def __call__(
         self,
         inputs: Union[Dict[str, Any], Any],
@@ -385,7 +385,7 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
             include_run_info=include_run_info,
         )
 
-    @deprecated("0.1.0", alternative="ainvoke", removal="0.3.0")
+    @deprecated("0.1.0", alternative="ainvoke", removal="1.0")
     async def acall(
         self,
         inputs: Union[Dict[str, Any], Any],
@@ -544,7 +544,7 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
             )
         return self.output_keys[0]
 
-    @deprecated("0.1.0", alternative="invoke", removal="0.3.0")
+    @deprecated("0.1.0", alternative="invoke", removal="1.0")
     def run(
         self,
         *args: Any,
@@ -615,7 +615,7 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
                 f" but not both. Got args: {args} and kwargs: {kwargs}."
             )
 
-    @deprecated("0.1.0", alternative="ainvoke", removal="0.3.0")
+    @deprecated("0.1.0", alternative="ainvoke", removal="1.0")
     async def arun(
         self,
         *args: Any,
@@ -753,7 +753,7 @@ class Chain(RunnableSerializable[Dict[str, Any], Dict[str, Any]], ABC):
         else:
             raise ValueError(f"{save_path} must be json or yaml")
 
-    @deprecated("0.1.0", alternative="batch", removal="0.3.0")
+    @deprecated("0.1.0", alternative="batch", removal="1.0")
     def apply(
         self, input_list: List[Dict[str, Any]], callbacks: Callbacks = None
     ) -> List[Dict[str, str]]:

langchain/chains/combine_documents/base.py

@@ -22,11 +22,11 @@ DOCUMENTS_KEY = "context"
 DEFAULT_DOCUMENT_PROMPT = PromptTemplate.from_template("{page_content}")
 
 
-def _validate_prompt(prompt: BasePromptTemplate) -> None:
-    if DOCUMENTS_KEY not in prompt.input_variables:
+def _validate_prompt(prompt: BasePromptTemplate, document_variable_name: str) -> None:
+    if document_variable_name not in prompt.input_variables:
         raise ValueError(
-            f"Prompt must accept {DOCUMENTS_KEY} as an input variable. Received prompt "
-            f"with input variables: {prompt.input_variables}"
+            f"Prompt must accept {document_variable_name} as an input variable. "
+            f"Received prompt with input variables: {prompt.input_variables}"
         )
 
 

langchain/chains/combine_documents/stuff.py

@@ -76,7 +76,7 @@ def create_stuff_documents_chain(
             chain.invoke({"context": docs})
     """  # noqa: E501
 
-    _validate_prompt(prompt)
+    _validate_prompt(prompt, document_variable_name)
     _document_prompt = document_prompt or DEFAULT_DOCUMENT_PROMPT
     _output_parser = output_parser or StrOutputParser()
 

langchain/chains/constitutional_ai/base.py

@@ -2,6 +2,7 @@
 
 from typing import Any, Dict, List, Optional
 
+from langchain_core._api import deprecated
 from langchain_core.callbacks import CallbackManagerForChainRun
 from langchain_core.language_models import BaseLanguageModel
 from langchain_core.prompts import BasePromptTemplate
@@ -13,9 +14,151 @@ from langchain.chains.constitutional_ai.prompts import CRITIQUE_PROMPT, REVISION
 from langchain.chains.llm import LLMChain
 
 
+@deprecated(
+    since="0.2.13",
+    message=(
+        "This class is deprecated and will be removed in langchain 1.0. "
+        "See API reference for replacement: "
+        "https://api.python.langchain.com/en/latest/chains/langchain.chains.constitutional_ai.base.ConstitutionalChain.html"  # noqa: E501
+    ),
+    removal="1.0",
+)
 class ConstitutionalChain(Chain):
     """Chain for applying constitutional principles.
 
+    Note: this class is deprecated. See below for a replacement implementation
+        using LangGraph. The benefits of this implementation are:
+
+        - Uses LLM tool calling features instead of parsing string responses;
+        - Support for both token-by-token and step-by-step streaming;
+        - Support for checkpointing and memory of chat history;
+        - Easier to modify or extend (e.g., with additional tools, structured responses, etc.)
+
+        Install LangGraph with:
+
+        .. code-block:: bash
+
+            pip install -U langgraph
+
+        .. code-block:: python
+
+            from typing import List, Optional, Tuple
+
+            from langchain.chains.constitutional_ai.prompts import (
+                CRITIQUE_PROMPT,
+                REVISION_PROMPT,
+            )
+            from langchain.chains.constitutional_ai.models import ConstitutionalPrinciple
+            from langchain_core.output_parsers import StrOutputParser
+            from langchain_core.prompts import ChatPromptTemplate
+            from langchain_openai import ChatOpenAI
+            from langgraph.graph import END, START, StateGraph
+            from typing_extensions import Annotated, TypedDict
+
+            llm = ChatOpenAI(model="gpt-4o-mini")
+
+            class Critique(TypedDict):
+                \"\"\"Generate a critique, if needed.\"\"\"
+                critique_needed: Annotated[bool, ..., "Whether or not a critique is needed."]
+                critique: Annotated[str, ..., "If needed, the critique."]
+
+            critique_prompt = ChatPromptTemplate.from_template(
+                "Critique this response according to the critique request. "
+                "If no critique is needed, specify that.\\n\\n"
+                "Query: {query}\\n\\n"
+                "Response: {response}\\n\\n"
+                "Critique request: {critique_request}"
+            )
+
+            revision_prompt = ChatPromptTemplate.from_template(
+                "Revise this response according to the critique and reivsion request.\\n\\n"
+                "Query: {query}\\n\\n"
+                "Response: {response}\\n\\n"
+                "Critique request: {critique_request}\\n\\n"
+                "Critique: {critique}\\n\\n"
+                "If the critique does not identify anything worth changing, ignore the "
+                "revision request and return 'No revisions needed'. If the critique "
+                "does identify something worth changing, revise the response based on "
+                "the revision request.\\n\\n"
+                "Revision Request: {revision_request}"
+            )
+
+            chain = llm | StrOutputParser()
+            critique_chain = critique_prompt | llm.with_structured_output(Critique)
+            revision_chain = revision_prompt | llm | StrOutputParser()
+
+
+            class State(TypedDict):
+                query: str
+                constitutional_principles: List[ConstitutionalPrinciple]
+                initial_response: str
+                critiques_and_revisions: List[Tuple[str, str]]
+                response: str
+
+
+            async def generate_response(state: State):
+                \"\"\"Generate initial response.\"\"\"
+                response = await chain.ainvoke(state["query"])
+                return {"response": response, "initial_response": response}
+
+            async def critique_and_revise(state: State):
+                \"\"\"Critique and revise response according to principles.\"\"\"
+                critiques_and_revisions = []
+                response = state["initial_response"]
+                for principle in state["constitutional_principles"]:
+                    critique = await critique_chain.ainvoke(
+                        {
+                            "query": state["query"],
+                            "response": response,
+                            "critique_request": principle.critique_request,
+                        }
+                    )
+                    if critique["critique_needed"]:
+                        revision = await revision_chain.ainvoke(
+                            {
+                                "query": state["query"],
+                                "response": response,
+                                "critique_request": principle.critique_request,
+                                "critique": critique["critique"],
+                                "revision_request": principle.revision_request,
+                            }
+                        )
+                        response = revision
+                        critiques_and_revisions.append((critique["critique"], revision))
+                    else:
+                        critiques_and_revisions.append((critique["critique"], ""))
+                return {
+                    "critiques_and_revisions": critiques_and_revisions,
+                    "response": response,
+                }
+
+            graph = StateGraph(State)
+            graph.add_node("generate_response", generate_response)
+            graph.add_node("critique_and_revise", critique_and_revise)
+
+            graph.add_edge(START, "generate_response")
+            graph.add_edge("generate_response", "critique_and_revise")
+            graph.add_edge("critique_and_revise", END)
+            app = graph.compile()
+
+        .. code-block:: python
+
+            constitutional_principles=[
+                ConstitutionalPrinciple(
+                    critique_request="Tell if this answer is good.",
+                    revision_request="Give a better answer.",
+                )
+            ]
+
+            query = "What is the meaning of life? Answer in 10 words or fewer."
+
+            async for step in app.astream(
+                {"query": query, "constitutional_principles": constitutional_principles},
+                stream_mode="values",
+            ):
+                subset = ["initial_response", "critiques_and_revisions", "response"]
+                print({k: v for k, v in step.items() if k in subset})
+
     Example:
         .. code-block:: python
 
@@ -44,7 +187,7 @@ class ConstitutionalChain(Chain):
             )
 
             constitutional_chain.run(question="What is the meaning of life?")
-    """
+    """  # noqa: E501
 
     chain: LLMChain
     constitutional_principles: List[ConstitutionalPrinciple]

langchain/chains/conversation/base.py

@@ -16,7 +16,7 @@ from langchain.memory.buffer import ConversationBufferMemory
     since="0.2.7",
     alternative=(
         "RunnableWithMessageHistory: "
-        "https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html"  # noqa: E501
+        "https://python.langchain.com/v0.2/api_reference/core/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html"  # noqa: E501
     ),
     removal="1.0",
 )

langchain/chains/conversational_retrieval/base.py

@@ -242,7 +242,7 @@ class BaseConversationalRetrievalChain(Chain):
         "create_history_aware_retriever together with create_retrieval_chain "
         "(see example in docstring)"
     ),
-    removal="0.3.0",
+    removal="1.0",
 )
 class ConversationalRetrievalChain(BaseConversationalRetrievalChain):
     """Chain for having a conversation based on retrieved documents.

langchain/chains/flare/base.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import re
-from abc import abstractmethod
 from typing import Any, Dict, List, Optional, Sequence, Tuple
 
 import numpy as np
@@ -9,10 +8,12 @@ from langchain_core.callbacks import (
     CallbackManagerForChainRun,
 )
 from langchain_core.language_models import BaseLanguageModel
-from langchain_core.outputs import Generation
+from langchain_core.messages import AIMessage
+from langchain_core.output_parsers import StrOutputParser
 from langchain_core.prompts import BasePromptTemplate
 from langchain_core.pydantic_v1 import Field
 from langchain_core.retrievers import BaseRetriever
+from langchain_core.runnables import Runnable
 
 from langchain.chains.base import Chain
 from langchain.chains.flare.prompts import (
@@ -23,51 +24,14 @@ from langchain.chains.flare.prompts import (
 from langchain.chains.llm import LLMChain
 
 
-class _ResponseChain(LLMChain):
-    """Base class for chains that generate responses."""
-
-    prompt: BasePromptTemplate = PROMPT
-
-    @classmethod
-    def is_lc_serializable(cls) -> bool:
-        return False
-
-    @property
-    def input_keys(self) -> List[str]:
-        return self.prompt.input_variables
-
-    def generate_tokens_and_log_probs(
-        self,
-        _input: Dict[str, Any],
-        *,
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Tuple[Sequence[str], Sequence[float]]:
-        llm_result = self.generate([_input], run_manager=run_manager)
-        return self._extract_tokens_and_log_probs(llm_result.generations[0])
-
-    @abstractmethod
-    def _extract_tokens_and_log_probs(
-        self, generations: List[Generation]
-    ) -> Tuple[Sequence[str], Sequence[float]]:
-        """Extract tokens and log probs from response."""
-
-
-class _OpenAIResponseChain(_ResponseChain):
-    """Chain that generates responses from user input and context."""
-
-    llm: BaseLanguageModel
-
-    def _extract_tokens_and_log_probs(
-        self, generations: List[Generation]
-    ) -> Tuple[Sequence[str], Sequence[float]]:
-        tokens = []
-        log_probs = []
-        for gen in generations:
-            if gen.generation_info is None:
-                raise ValueError
-            tokens.extend(gen.generation_info["logprobs"]["tokens"])
-            log_probs.extend(gen.generation_info["logprobs"]["token_logprobs"])
-        return tokens, log_probs
+def _extract_tokens_and_log_probs(response: AIMessage) -> Tuple[List[str], List[float]]:
+    """Extract tokens and log probabilities from chat model response."""
+    tokens = []
+    log_probs = []
+    for token in response.response_metadata["logprobs"]["content"]:
+        tokens.append(token["token"])
+        log_probs.append(token["logprob"])
+    return tokens, log_probs
 
 
 class QuestionGeneratorChain(LLMChain):
@@ -111,9 +75,9 @@ class FlareChain(Chain):
     """Chain that combines a retriever, a question generator,
     and a response generator."""
 
-    question_generator_chain: QuestionGeneratorChain
+    question_generator_chain: Runnable
     """Chain that generates questions from uncertain spans."""
-    response_chain: _ResponseChain
+    response_chain: Runnable
     """Chain that generates responses from user input and context."""
     output_parser: FinishedOutputParser = Field(default_factory=FinishedOutputParser)
     """Parser that determines whether the chain is finished."""
@@ -152,12 +116,16 @@ class FlareChain(Chain):
         for question in questions:
             docs.extend(self.retriever.invoke(question))
         context = "\n\n".join(d.page_content for d in docs)
-        result = self.response_chain.predict(
-            user_input=user_input,
-            context=context,
-            response=response,
-            callbacks=callbacks,
+        result = self.response_chain.invoke(
+            {
+                "user_input": user_input,
+                "context": context,
+                "response": response,
+            },
+            {"callbacks": callbacks},
         )
+        if isinstance(result, AIMessage):
+            result = result.content
         marginal, finished = self.output_parser.parse(result)
         return marginal, finished
 
@@ -178,13 +146,18 @@ class FlareChain(Chain):
             for span in low_confidence_spans
         ]
         callbacks = _run_manager.get_child()
-        question_gen_outputs = self.question_generator_chain.apply(
-            question_gen_inputs, callbacks=callbacks
-        )
-        questions = [
-            output[self.question_generator_chain.output_keys[0]]
-            for output in question_gen_outputs
-        ]
+        if isinstance(self.question_generator_chain, LLMChain):
+            question_gen_outputs = self.question_generator_chain.apply(
+                question_gen_inputs, callbacks=callbacks
+            )
+            questions = [
+                output[self.question_generator_chain.output_keys[0]]
+                for output in question_gen_outputs
+            ]
+        else:
+            questions = self.question_generator_chain.batch(
+                question_gen_inputs, config={"callbacks": callbacks}
+            )
         _run_manager.on_text(
             f"Generated Questions: {questions}", color="yellow", end="\n"
         )
@@ -206,8 +179,10 @@ class FlareChain(Chain):
                 f"Current Response: {response}", color="blue", end="\n"
             )
             _input = {"user_input": user_input, "context": "", "response": response}
-            tokens, log_probs = self.response_chain.generate_tokens_and_log_probs(
-                _input, run_manager=_run_manager
+            tokens, log_probs = _extract_tokens_and_log_probs(
+                self.response_chain.invoke(
+                    _input, {"callbacks": _run_manager.get_child()}
+                )
             )
             low_confidence_spans = _low_confidence_spans(
                 tokens,
@@ -251,18 +226,16 @@ class FlareChain(Chain):
             FlareChain class with the given language model.
         """
         try:
-            from langchain_openai import OpenAI
+            from langchain_openai import ChatOpenAI
         except ImportError:
             raise ImportError(
                 "OpenAI is required for FlareChain. "
                 "Please install langchain-openai."
                 "pip install langchain-openai"
             )
-        question_gen_chain = QuestionGeneratorChain(llm=llm)
-        response_llm = OpenAI(
-            max_tokens=max_generation_len, model_kwargs={"logprobs": 1}, temperature=0
-        )
-        response_chain = _OpenAIResponseChain(llm=response_llm)
+        llm = ChatOpenAI(max_tokens=max_generation_len, logprobs=True, temperature=0)
+        response_chain = PROMPT | llm
+        question_gen_chain = QUESTION_GENERATOR_PROMPT | llm | StrOutputParser()
         return cls(
             question_generator_chain=question_gen_chain,
             response_chain=response_chain,

langchain/chains/hyde/base.py

@@ -11,7 +11,9 @@ import numpy as np
 from langchain_core.callbacks import CallbackManagerForChainRun
 from langchain_core.embeddings import Embeddings
 from langchain_core.language_models import BaseLanguageModel
+from langchain_core.output_parsers import StrOutputParser
 from langchain_core.prompts import BasePromptTemplate
+from langchain_core.runnables import Runnable
 
 from langchain.chains.base import Chain
 from langchain.chains.hyde.prompts import PROMPT_MAP
@@ -25,7 +27,7 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
     """
 
     base_embeddings: Embeddings
-    llm_chain: LLMChain
+    llm_chain: Runnable
 
     class Config:
         arbitrary_types_allowed = True
@@ -34,12 +36,15 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
     @property
     def input_keys(self) -> List[str]:
         """Input keys for Hyde's LLM chain."""
-        return self.llm_chain.input_keys
+        return self.llm_chain.input_schema.schema()["required"]
 
     @property
     def output_keys(self) -> List[str]:
         """Output keys for Hyde's LLM chain."""
-        return self.llm_chain.output_keys
+        if isinstance(self.llm_chain, LLMChain):
+            return self.llm_chain.output_keys
+        else:
+            return ["text"]
 
     def embed_documents(self, texts: List[str]) -> List[List[float]]:
         """Call the base embeddings."""
@@ -51,9 +56,12 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
 
     def embed_query(self, text: str) -> List[float]:
         """Generate a hypothetical document and embedded it."""
-        var_name = self.llm_chain.input_keys[0]
-        result = self.llm_chain.generate([{var_name: text}])
-        documents = [generation.text for generation in result.generations[0]]
+        var_name = self.input_keys[0]
+        result = self.llm_chain.invoke({var_name: text})
+        if isinstance(self.llm_chain, LLMChain):
+            documents = [result[self.output_keys[0]]]
+        else:
+            documents = [result]
         embeddings = self.embed_documents(documents)
         return self.combine_embeddings(embeddings)
 
@@ -64,7 +72,9 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
     ) -> Dict[str, str]:
         """Call the internal llm chain."""
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
-        return self.llm_chain(inputs, callbacks=_run_manager.get_child())
+        return self.llm_chain.invoke(
+            inputs, config={"callbacks": _run_manager.get_child()}
+        )
 
     @classmethod
     def from_llm(
@@ -86,7 +96,7 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
                 f"of {list(PROMPT_MAP.keys())}."
             )
 
-        llm_chain = LLMChain(llm=llm, prompt=prompt)
+        llm_chain = prompt | llm | StrOutputParser()
         return cls(base_embeddings=base_embeddings, llm_chain=llm_chain, **kwargs)
 
     @property