langchain 0.2.14__py3-none-any.whl → 0.2.16__py3-none-any.whl

langchain/agents/agent.py

@@ -19,6 +19,7 @@ from typing import (
     Sequence,
     Tuple,
     Union,
+    cast,
 )
 
 import yaml
@@ -629,7 +630,7 @@ class RunnableMultiActionAgent(BaseMultiActionAgent):
 
 @deprecated(
     "0.1.0",
-    alternative=(
+    message=(
         "Use new agent constructor methods like create_react_agent, create_json_agent, "
         "create_structured_chat_agent, etc."
     ),
@@ -720,7 +721,7 @@ class LLMSingleActionAgent(BaseSingleActionAgent):
 
 @deprecated(
     "0.1.0",
-    alternative=(
+    message=(
         "Use new agent constructor methods like create_react_agent, create_json_agent, "
         "create_structured_chat_agent, etc."
     ),
@@ -1042,12 +1043,13 @@ class ExceptionTool(BaseTool):
 
 
 NextStepOutput = List[Union[AgentFinish, AgentAction, AgentStep]]
+RunnableAgentType = Union[RunnableAgent, RunnableMultiActionAgent]
 
 
 class AgentExecutor(Chain):
     """Agent that is using tools."""
 
-    agent: Union[BaseSingleActionAgent, BaseMultiActionAgent]
+    agent: Union[BaseSingleActionAgent, BaseMultiActionAgent, Runnable]
     """The agent to run for creating a plan and determining actions
     to take at each step of the execution loop."""
     tools: Sequence[BaseTool]
@@ -1095,7 +1097,7 @@ class AgentExecutor(Chain):
     @classmethod
     def from_agent_and_tools(
         cls,
-        agent: Union[BaseSingleActionAgent, BaseMultiActionAgent],
+        agent: Union[BaseSingleActionAgent, BaseMultiActionAgent, Runnable],
         tools: Sequence[BaseTool],
         callbacks: Callbacks = None,
         **kwargs: Any,
@@ -1172,6 +1174,21 @@ class AgentExecutor(Chain):
                 )
         return values
 
+    @property
+    def _action_agent(self) -> Union[BaseSingleActionAgent, BaseMultiActionAgent]:
+        """Type cast self.agent.
+
+        The .agent attribute type includes Runnable, but is converted to one of
+        RunnableAgentType in the validate_runnable_agent root_validator.
+
+        To support instantiating with a Runnable, here we explicitly cast the type
+        to reflect the changes made in the root_validator.
+        """
+        if isinstance(self.agent, Runnable):
+            return cast(RunnableAgentType, self.agent)
+        else:
+            return self.agent
+
     def save(self, file_path: Union[Path, str]) -> None:
         """Raise error - saving not supported for Agent Executors.
 
@@ -1193,7 +1210,7 @@ class AgentExecutor(Chain):
         Args:
             file_path: Path to save to.
         """
-        return self.agent.save(file_path)
+        return self._action_agent.save(file_path)
 
     def iter(
         self,
@@ -1228,7 +1245,7 @@ class AgentExecutor(Chain):
 
         :meta private:
         """
-        return self.agent.input_keys
+        return self._action_agent.input_keys
 
     @property
     def output_keys(self) -> List[str]:
@@ -1237,9 +1254,9 @@ class AgentExecutor(Chain):
         :meta private:
         """
         if self.return_intermediate_steps:
-            return self.agent.return_values + ["intermediate_steps"]
+            return self._action_agent.return_values + ["intermediate_steps"]
         else:
-            return self.agent.return_values
+            return self._action_agent.return_values
 
     def lookup_tool(self, name: str) -> BaseTool:
         """Lookup tool by name.
@@ -1339,7 +1356,7 @@ class AgentExecutor(Chain):
             intermediate_steps = self._prepare_intermediate_steps(intermediate_steps)
 
             # Call the LLM to see what to do.
-            output = self.agent.plan(
+            output = self._action_agent.plan(
                 intermediate_steps,
                 callbacks=run_manager.get_child() if run_manager else None,
                 **inputs,
@@ -1372,7 +1389,7 @@ class AgentExecutor(Chain):
             output = AgentAction("_Exception", observation, text)
             if run_manager:
                 run_manager.on_agent_action(output, color="green")
-            tool_run_kwargs = self.agent.tool_run_logging_kwargs()
+            tool_run_kwargs = self._action_agent.tool_run_logging_kwargs()
             observation = ExceptionTool().run(
                 output.tool_input,
                 verbose=self.verbose,
@@ -1414,7 +1431,7 @@ class AgentExecutor(Chain):
             tool = name_to_tool_map[agent_action.tool]
             return_direct = tool.return_direct
             color = color_mapping[agent_action.tool]
-            tool_run_kwargs = self.agent.tool_run_logging_kwargs()
+            tool_run_kwargs = self._action_agent.tool_run_logging_kwargs()
             if return_direct:
                 tool_run_kwargs["llm_prefix"] = ""
             # We then call the tool on the tool input to get an observation
@@ -1426,7 +1443,7 @@ class AgentExecutor(Chain):
                 **tool_run_kwargs,
             )
         else:
-            tool_run_kwargs = self.agent.tool_run_logging_kwargs()
+            tool_run_kwargs = self._action_agent.tool_run_logging_kwargs()
             observation = InvalidTool().run(
                 {
                     "requested_tool_name": agent_action.tool,
@@ -1476,7 +1493,7 @@ class AgentExecutor(Chain):
             intermediate_steps = self._prepare_intermediate_steps(intermediate_steps)
 
             # Call the LLM to see what to do.
-            output = await self.agent.aplan(
+            output = await self._action_agent.aplan(
                 intermediate_steps,
                 callbacks=run_manager.get_child() if run_manager else None,
                 **inputs,
@@ -1507,7 +1524,7 @@ class AgentExecutor(Chain):
             else:
                 raise ValueError("Got unexpected type of `handle_parsing_errors`")
             output = AgentAction("_Exception", observation, text)
-            tool_run_kwargs = self.agent.tool_run_logging_kwargs()
+            tool_run_kwargs = self._action_agent.tool_run_logging_kwargs()
             observation = await ExceptionTool().arun(
                 output.tool_input,
                 verbose=self.verbose,
@@ -1561,7 +1578,7 @@ class AgentExecutor(Chain):
             tool = name_to_tool_map[agent_action.tool]
             return_direct = tool.return_direct
             color = color_mapping[agent_action.tool]
-            tool_run_kwargs = self.agent.tool_run_logging_kwargs()
+            tool_run_kwargs = self._action_agent.tool_run_logging_kwargs()
             if return_direct:
                 tool_run_kwargs["llm_prefix"] = ""
             # We then call the tool on the tool input to get an observation
@@ -1573,7 +1590,7 @@ class AgentExecutor(Chain):
                 **tool_run_kwargs,
             )
         else:
-            tool_run_kwargs = self.agent.tool_run_logging_kwargs()
+            tool_run_kwargs = self._action_agent.tool_run_logging_kwargs()
             observation = await InvalidTool().arun(
                 {
                     "requested_tool_name": agent_action.tool,
@@ -1628,7 +1645,7 @@ class AgentExecutor(Chain):
                     )
             iterations += 1
             time_elapsed = time.time() - start_time
-        output = self.agent.return_stopped_response(
+        output = self._action_agent.return_stopped_response(
             self.early_stopping_method, intermediate_steps, **inputs
         )
         return self._return(output, intermediate_steps, run_manager=run_manager)
@@ -1680,7 +1697,7 @@ class AgentExecutor(Chain):
 
                     iterations += 1
                     time_elapsed = time.time() - start_time
-                output = self.agent.return_stopped_response(
+                output = self._action_agent.return_stopped_response(
                     self.early_stopping_method, intermediate_steps, **inputs
                 )
                 return await self._areturn(
@@ -1688,7 +1705,7 @@ class AgentExecutor(Chain):
                 )
         except (TimeoutError, asyncio.TimeoutError):
             # stop early when interrupted by the async timeout
-            output = self.agent.return_stopped_response(
+            output = self._action_agent.return_stopped_response(
                 self.early_stopping_method, intermediate_steps, **inputs
             )
             return await self._areturn(
@@ -1702,8 +1719,8 @@ class AgentExecutor(Chain):
         agent_action, observation = next_step_output
         name_to_tool_map = {tool.name: tool for tool in self.tools}
         return_value_key = "output"
-        if len(self.agent.return_values) > 0:
-            return_value_key = self.agent.return_values[0]
+        if len(self._action_agent.return_values) > 0:
+            return_value_key = self._action_agent.return_values[0]
         # Invalid tools won't be in the map, so we return False.
         if agent_action.tool in name_to_tool_map:
             if name_to_tool_map[agent_action.tool].return_direct:

langchain/agents/agent_iterator.py

@@ -371,7 +371,7 @@ class AgentExecutorIterator:
         """
         logger.warning("Stopping agent prematurely due to triggering stop condition")
         # this manually constructs agent finish with output key
-        output = self.agent_executor.agent.return_stopped_response(
+        output = self.agent_executor._action_agent.return_stopped_response(
             self.agent_executor.early_stopping_method,
             self.intermediate_steps,
             **self.inputs,
@@ -384,7 +384,7 @@ class AgentExecutorIterator:
         the stopped response.
         """
         logger.warning("Stopping agent prematurely due to triggering stop condition")
-        output = self.agent_executor.agent.return_stopped_response(
+        output = self.agent_executor._action_agent.return_stopped_response(
             self.agent_executor.early_stopping_method,
             self.intermediate_steps,
             **self.inputs,

langchain/agents/agent_types.py

@@ -7,7 +7,7 @@ from langchain_core._api import deprecated
 
 @deprecated(
     "0.1.0",
-    alternative=(
+    message=(
         "Use new agent constructor methods like create_react_agent, create_json_agent, "
         "create_structured_chat_agent, etc."
     ),

langchain/agents/openai_assistant/base.py

@@ -272,7 +272,6 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
             instructions=instructions,
             tools=[_get_assistants_tool(tool) for tool in tools],  # type: ignore
             model=model,
-            file_ids=kwargs.get("file_ids"),
         )
         return cls(assistant_id=assistant.id, client=client, **kwargs)
 
@@ -287,7 +286,6 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
                 thread_id: Existing thread to use.
                 run_id: Existing run to use. Should only be supplied when providing
                     the tool output for a required action after an initial invocation.
-                file_ids: File ids to include in new run. Used for retrieval.
                 message_metadata: Metadata to associate with new message.
                 thread_metadata: Metadata to associate with new thread. Only relevant
                     when new thread being created.
@@ -327,7 +325,6 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
                         {
                             "role": "user",
                             "content": input["content"],
-                            "file_ids": input.get("file_ids", []),
                             "metadata": input.get("message_metadata"),
                         }
                     ],
@@ -340,7 +337,6 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
                     input["thread_id"],
                     content=input["content"],
                     role="user",
-                    file_ids=input.get("file_ids", []),
                     metadata=input.get("message_metadata"),
                 )
                 run = self._create_run(input)
@@ -394,7 +390,6 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
             instructions=instructions,
             tools=openai_tools,  # type: ignore
             model=model,
-            file_ids=kwargs.get("file_ids"),
         )
         return cls(assistant_id=assistant.id, async_client=async_client, **kwargs)
 
@@ -409,7 +404,6 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
                 thread_id: Existing thread to use.
                 run_id: Existing run to use. Should only be supplied when providing
                     the tool output for a required action after an initial invocation.
-                file_ids: File ids to include in new run. Used for retrieval.
                 message_metadata: Metadata to associate with a new message.
                 thread_metadata: Metadata to associate with new thread. Only relevant
                     when a new thread is created.
@@ -439,7 +433,7 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
         try:
             # Being run within AgentExecutor and there are tool outputs to submit.
             if self.as_agent and input.get("intermediate_steps"):
-                tool_outputs = self._parse_intermediate_steps(
+                tool_outputs = await self._aparse_intermediate_steps(
                     input["intermediate_steps"]
                 )
                 run = await self.async_client.beta.threads.runs.submit_tool_outputs(
@@ -452,7 +446,6 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
                         {
                             "role": "user",
                             "content": input["content"],
-                            "file_ids": input.get("file_ids", []),
                             "metadata": input.get("message_metadata"),
                         }
                     ],
@@ -465,7 +458,6 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
                     input["thread_id"],
                     content=input["content"],
                     role="user",
-                    file_ids=input.get("file_ids", []),
                     metadata=input.get("message_metadata"),
                 )
                 run = await self._acreate_run(input)
@@ -493,9 +485,11 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
     ) -> dict:
         last_action, last_output = intermediate_steps[-1]
         run = self._wait_for_run(last_action.run_id, last_action.thread_id)
-        required_tool_call_ids = {
-            tc.id for tc in run.required_action.submit_tool_outputs.tool_calls
-        }
+        required_tool_call_ids = set()
+        if run.required_action:
+            required_tool_call_ids = {
+                tc.id for tc in run.required_action.submit_tool_outputs.tool_calls
+            }
         tool_outputs = [
             {"output": str(output), "tool_call_id": action.tool_call_id}
             for action, output in intermediate_steps
@@ -621,9 +615,11 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
     ) -> dict:
         last_action, last_output = intermediate_steps[-1]
         run = await self._wait_for_run(last_action.run_id, last_action.thread_id)
-        required_tool_call_ids = {
-            tc.id for tc in run.required_action.submit_tool_outputs.tool_calls
-        }
+        required_tool_call_ids = set()
+        if run.required_action:
+            required_tool_call_ids = {
+                tc.id for tc in run.required_action.submit_tool_outputs.tool_calls
+            }
         tool_outputs = [
             {"output": str(output), "tool_call_id": action.tool_call_id}
             for action, output in intermediate_steps

langchain/agents/openai_tools/base.py

@@ -1,4 +1,4 @@
-from typing import Sequence
+from typing import Optional, Sequence
 
 from langchain_core.language_models import BaseLanguageModel
 from langchain_core.prompts.chat import ChatPromptTemplate
@@ -13,7 +13,10 @@ from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputP
 
 
 def create_openai_tools_agent(
-    llm: BaseLanguageModel, tools: Sequence[BaseTool], prompt: ChatPromptTemplate
+    llm: BaseLanguageModel,
+    tools: Sequence[BaseTool],
+    prompt: ChatPromptTemplate,
+    strict: Optional[bool] = None,
 ) -> Runnable:
     """Create an agent that uses OpenAI tools.
 
@@ -87,7 +90,9 @@ def create_openai_tools_agent(
     if missing_vars:
         raise ValueError(f"Prompt missing required variables: {missing_vars}")
 
-    llm_with_tools = llm.bind(tools=[convert_to_openai_tool(tool) for tool in tools])
+    llm_with_tools = llm.bind(
+        tools=[convert_to_openai_tool(tool, strict=strict) for tool in tools]
+    )
 
     agent = (
         RunnablePassthrough.assign(

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",
 )