`langchain.agents.mrkl.base`.MRKLChain¶

class langchain.agents.mrkl.base.MRKLChain(*, memory: Optional[BaseMemory] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, callback_manager: Optional[BaseCallbackManager] = None, verbose: bool = None, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, agent: Union[BaseSingleActionAgent, BaseMultiActionAgent], tools: Sequence[BaseTool], return_intermediate_steps: bool = False, max_iterations: Optional[int] = 15, max_execution_time: Optional[float] = None, early_stopping_method: str = 'force', handle_parsing_errors: Union[bool, str, Callable[[OutputParserException], str]] = False, trim_intermediate_steps: Union[int, Callable[[List[Tuple[AgentAction, str]]], List[Tuple[AgentAction, str]]]] = - 1)[source]¶

Bases: AgentExecutor

Chain that implements the MRKL system.

Example

from langchain import OpenAI, MRKLChain
from langchain.chains.mrkl.base import ChainConfig
llm = OpenAI(temperature=0)
prompt = PromptTemplate(...)
chains = [...]
mrkl = MRKLChain.from_chains(llm=llm, prompt=prompt)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

param agent: Union[BaseSingleActionAgent, BaseMultiActionAgent] [Required]¶: The agent to run for creating a plan and determining actions to take at each step of the execution loop.

param callback_manager: Optional[BaseCallbackManager] = None¶: Deprecated, use callbacks instead.

param callbacks: Callbacks = None¶: Optional list of callback handlers (or callback manager). Defaults to None. Callback handlers are called throughout the lifecycle of a call to a chain, starting with on_chain_start, ending with on_chain_end or on_chain_error. Each custom chain can optionally call additional callback methods, see Callback docs for full details.

param early_stopping_method: str = 'force'¶

The method to use for early stopping if the agent never returns AgentFinish. Either ‘force’ or ‘generate’.

“force” returns a string saying that it stopped because it met a: time or iteration limit.
“generate” calls the agent’s LLM Chain one final time to generate: a final answer based on the previous steps.

param handle_parsing_errors: Union[bool, str, Callable[[OutputParserException], str]] = False¶

How to handle errors raised by the agent’s output parser.

Defaults to False, which raises the error.

s

If true, the error will be sent back to the LLM as an observation. If a string, the string itself will be sent to the LLM as an observation. If a callable function, the function will be called with the exception

as an argument, and the result of that function will be passed to the agent
as an observation.

param max_execution_time: Optional[float] = None¶: The maximum amount of wall clock time to spend in the execution loop.

param max_iterations: Optional[int] = 15¶

The maximum number of steps to take before ending the execution loop.

Setting to ‘None’ could lead to an infinite loop.

param memory: Optional[BaseMemory] = None¶: Optional memory object. Defaults to None. Memory is a class that gets called at the start and at the end of every chain. At the start, memory loads variables and passes them along in the chain. At the end, it saves any returned variables. There are many different types of memory - please see memory docs for the full catalog.

param metadata: Optional[Dict[str, Any]] = None¶: Optional metadata associated with the chain. Defaults to None. This metadata will be associated with each call to this chain, and passed as arguments to the handlers defined in callbacks. You can use these to eg identify a specific instance of a chain with its use case.

param return_intermediate_steps: bool = False¶: Whether to return the agent’s trajectory of intermediate steps at the end in addition to the final output.

param tags: Optional[List[str]] = None¶: Optional list of tags associated with the chain. Defaults to None. These tags will be associated with each call to this chain, and passed as arguments to the handlers defined in callbacks. You can use these to eg identify a specific instance of a chain with its use case.

param tools: Sequence[BaseTool] [Required]¶: The valid tools the agent can call.

param trim_intermediate_steps: Union[int, Callable[[List[Tuple[AgentAction, str]]], List[Tuple[AgentAction, str]]]] = -1¶

param verbose: bool [Optional]¶: Whether or not run in verbose mode. In verbose mode, some intermediate logs will be printed to the console. Defaults to langchain.verbose value.

__call__(inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, include_run_info: bool = False) → Dict[str, Any]¶

Execute the chain.

Parameters

inputs – Dictionary of inputs, or single input if chain expects only one param. Should contain all inputs specified in Chain.input_keys except for inputs that will be set by the chain’s memory.
return_only_outputs – Whether to return only outputs in the response. If True, only new keys generated by this chain will be returned. If False, both input keys and new keys generated by this chain will be returned. Defaults to False.
callbacks – Callbacks to use for this chain run. These will be called in addition to callbacks passed to the chain during construction, but only these runtime callbacks will propagate to calls to other objects.
tags – List of string tags to pass to all callbacks. These will be passed in addition to tags passed to the chain during construction, but only these runtime tags will propagate to calls to other objects.
metadata – Optional metadata associated with the chain. Defaults to None
include_run_info – Whether to include run info in the response. Defaults to False.

Returns

A dict of named outputs. Should contain all outputs specified in: Chain.output_keys.

async acall(inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, include_run_info: bool = False) → Dict[str, Any]¶

Asynchronously execute the chain.

Parameters

inputs – Dictionary of inputs, or single input if chain expects only one param. Should contain all inputs specified in Chain.input_keys except for inputs that will be set by the chain’s memory.
return_only_outputs – Whether to return only outputs in the response. If True, only new keys generated by this chain will be returned. If False, both input keys and new keys generated by this chain will be returned. Defaults to False.
callbacks – Callbacks to use for this chain run. These will be called in addition to callbacks passed to the chain during construction, but only these runtime callbacks will propagate to calls to other objects.
tags – List of string tags to pass to all callbacks. These will be passed in addition to tags passed to the chain during construction, but only these runtime tags will propagate to calls to other objects.
metadata – Optional metadata associated with the chain. Defaults to None
include_run_info – Whether to include run info in the response. Defaults to False.

Returns

A dict of named outputs. Should contain all outputs specified in: Chain.output_keys.

async ainvoke(input: Dict[str, Any], config: Optional[RunnableConfig] = None) → Dict[str, Any]¶

apply(input_list: List[Dict[str, Any]], callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None) → List[Dict[str, str]]¶: Call the chain on all inputs in the list.

async arun(*args: Any, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs: Any) → Any¶

Convenience method for executing chain.

The main difference between this method and Chain.__call__ is that this method expects inputs to be passed directly in as positional arguments or keyword arguments, whereas Chain.__call__ expects a single input dictionary with all the inputs

Parameters

*args – If the chain expects a single input, it can be passed in as the sole positional argument.
callbacks – Callbacks to use for this chain run. These will be called in addition to callbacks passed to the chain during construction, but only these runtime callbacks will propagate to calls to other objects.
tags – List of string tags to pass to all callbacks. These will be passed in addition to tags passed to the chain during construction, but only these runtime tags will propagate to calls to other objects.
**kwargs – If the chain expects multiple inputs, they can be passed in directly as keyword arguments.

Returns

The chain output.

Example

# Suppose we have a single-input chain that takes a 'question' string:
await chain.arun("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."

# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
await chain.arun(question=question, context=context)
# -> "The temperature in Boise is..."

dict(**kwargs: Any) → Dict¶

Dictionary representation of chain.

Expects Chain._chain_type property to be implemented and for memory to be: null.

Parameters: **kwargs – Keyword arguments passed to default pydantic.BaseModel.dict method.
Returns: A dictionary representation of the chain.

Example

..code-block:: python

chain.dict(exclude_unset=True) # -> {“_type”: “foo”, “verbose”: False, …}

classmethod from_agent_and_tools(agent: Union[BaseSingleActionAgent, BaseMultiActionAgent], tools: Sequence[BaseTool], callback_manager: Optional[BaseCallbackManager] = None, **kwargs: Any) → AgentExecutor¶: Create from agent and tools.

classmethod from_chains(llm: BaseLanguageModel, chains: List[ChainConfig], **kwargs: Any) → AgentExecutor[source]¶

User friendly way to initialize the MRKL chain.

This is intended to be an easy way to get up and running with the MRKL chain.

Parameters

llm – The LLM to use as the agent LLM.
chains – The chains the MRKL system has access to.
**kwargs – parameters to be passed to initialization.

Returns

An initialized MRKL chain.

Example

from langchain import LLMMathChain, OpenAI, SerpAPIWrapper, MRKLChain
from langchain.chains.mrkl.base import ChainConfig
llm = OpenAI(temperature=0)
search = SerpAPIWrapper()
llm_math_chain = LLMMathChain(llm=llm)
chains = [
    ChainConfig(
        action_name = "Search",
        action=search.search,
        action_description="useful for searching"
    ),
    ChainConfig(
        action_name="Calculator",
        action=llm_math_chain.run,
        action_description="useful for doing math"
    )
]
mrkl = MRKLChain.from_chains(llm, chains)

invoke(input: Dict[str, Any], config: Optional[RunnableConfig] = None) → Dict[str, Any]¶

iter(inputs: Any, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, include_run_info: bool = False, async_: bool = False) → AgentExecutorIterator¶: Enables iteration over steps taken to reach final output.

lookup_tool(name: str) → BaseTool¶: Lookup tool by name.

prep_inputs(inputs: Union[Dict[str, Any], Any]) → Dict[str, str]¶

Validate and prepare chain inputs, including adding inputs from memory.

Parameters: inputs – Dictionary of raw inputs, or single input if chain expects only one param. Should contain all inputs specified in Chain.input_keys except for inputs that will be set by the chain’s memory.
Returns: A dictionary of all inputs, including those added by the chain’s memory.

prep_outputs(inputs: Dict[str, str], outputs: Dict[str, str], return_only_outputs: bool = False) → Dict[str, str]¶

Validate and prepare chain outputs, and save info about this run to memory.

Parameters

inputs – Dictionary of chain inputs, including any inputs added by chain memory.
outputs – Dictionary of initial chain outputs.
return_only_outputs – Whether to only return the chain outputs. If False, inputs are also added to the final outputs.

Returns

A dict of the final chain outputs.

validator raise_callback_manager_deprecation » all fields¶: Raise deprecation warning if callback_manager is used.

run(*args: Any, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs: Any) → Any¶

Convenience method for executing chain.

Parameters

*args – If the chain expects a single input, it can be passed in as the sole positional argument.
callbacks – Callbacks to use for this chain run. These will be called in addition to callbacks passed to the chain during construction, but only these runtime callbacks will propagate to calls to other objects.
tags – List of string tags to pass to all callbacks. These will be passed in addition to tags passed to the chain during construction, but only these runtime tags will propagate to calls to other objects.
**kwargs – If the chain expects multiple inputs, they can be passed in directly as keyword arguments.

Returns

The chain output.

Example

# Suppose we have a single-input chain that takes a 'question' string:
chain.run("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."

# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
chain.run(question=question, context=context)
# -> "The temperature in Boise is..."

save(file_path: Union[Path, str]) → None¶: Raise error - saving not supported for Agent Executors.

save_agent(file_path: Union[Path, str]) → None¶: Save the underlying agent.

validator set_verbose » verbose¶

Set the chain verbosity.

Defaults to the global setting if not specified by the user.

to_json() → Union[SerializedConstructor, SerializedNotImplemented]¶

to_json_not_implemented() → SerializedNotImplemented¶

validator validate_return_direct_tool » all fields¶: Validate that tools are compatible with agent.

validator validate_tools » all fields¶: Validate that tools are compatible with agent.

property lc_attributes: Dict¶: Return a list of attribute names that should be included in the serialized kwargs. These attributes must be accepted by the constructor.

property lc_namespace: List[str]¶: Return the namespace of the langchain object. eg. [“langchain”, “llms”, “openai”]

property lc_secrets: Dict[str, str]¶: Return a map of constructor argument names to secret ids. eg. {“openai_api_key”: “OPENAI_API_KEY”}

property lc_serializable: bool¶: Return whether or not the class is serializable.

model Config¶

Bases: object

Configuration for this pydantic object.

arbitrary_types_allowed = True¶

langchain.agents.mrkl.base.MRKLChain¶

`langchain.agents.mrkl.base`.MRKLChain¶