Tony20100/langchain_full huggingface dataset:
format = password
param url: Optional[SecretStr] = None¶
Url to Watson Machine Learning instance
Constraints
type = string
writeOnly = True
format = password
param username: Optional[SecretStr] = None¶
Username to Watson Machine Learning instance
Constraints
type = string
writeOnly = True
format = password
param verbose: bool [Optional]¶
Whether to print out response text.
param verify: Union[str, bool] = ''¶
User can pass as verify one of following:
the path to a CA_BUNDLE file
the path of directory with certificates of trusted CAs
True - default path to truststore will be taken
False - no verification will be made
param version: Optional[SecretStr] = None¶
Version of Watson Machine Learning instance
Constraints
type = string
writeOnly = True
format = password
param watsonx_model: Any = None¶
__call__(prompt: str, stop: Optional[List[str]] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs: Any) → str¶
[Deprecated] Check Cache and run the LLM on the given prompt and input.
Notes
Deprecated since version langchain-core==0.1.7: Use invoke instead.
Parameters
prompt (str) – 
stop (Optional[List[str]]) – 
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 
tags (Optional[List[str]]) – 
metadata (Optional[Dict[str, Any]]) – 
kwargs (Any) – 
Return type
str
langchain_community.llms.cloudflare_workersai.CloudflareWorkersAI¶
class langchain_community.llms.cloudflare_workersai.CloudflareWorkersAI[source]¶
Bases: LLM
Cloudflare Workers AI service.
To use, you must provide an API token and
account ID to access Cloudflare Workers AI, and
pass it as a named parameter to the constructor.
Example
from langchain_community.llms.cloudflare_workersai import CloudflareWorkersAI
my_account_id = "my_account_id"
my_api_token = "my_secret_api_token"
llm_model =  "@cf/meta/llama-2-7b-chat-int8"
cf_ai = CloudflareWorkersAI(
    account_id=my_account_id,
    api_token=my_api_token,
    model=llm_model
)
Initialize the Cloudflare Workers AI class.
param account_id: str [Required]¶
param api_token: str [Required]¶
param base_url: str = 'https://api.cloudflare.com/client/v4/accounts'¶
param cache: Union[BaseCache, bool, None] = None¶
Whether to cache the response.
If true, will use the global cache.
If false, will not use a cache
If None, will use the global cache if it’s set, otherwise no cache.
If instance of BaseCache, will use the provided cache.
Caching is not currently supported for streaming methods of models.
param callback_manager: Optional[BaseCallbackManager] = None¶
[DEPRECATED]
param callbacks: Callbacks = None¶
Callbacks to add to the run trace.
param custom_get_token_ids: Optional[Callable[[str], List[int]]] = None¶
Optional encoder to use for counting tokens.
param endpoint_url: str = ''¶
param metadata: Optional[Dict[str, Any]] = None¶
param metadata: Optional[Dict[str, Any]] = None¶
Metadata to add to the run trace.
param model: str = '@cf/meta/llama-2-7b-chat-int8'¶
param streaming: bool = False¶
param tags: Optional[List[str]] = None¶
Tags to add to the run trace.
param verbose: bool [Optional]¶
Whether to print out response text.
__call__(prompt: str, stop: Optional[List[str]] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs: Any) → str¶
[Deprecated] Check Cache and run the LLM on the given prompt and input.
Notes
Deprecated since version langchain-core==0.1.7: Use invoke instead.
Parameters
prompt (str) – 
stop (Optional[List[str]]) – 
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 
tags (Optional[List[str]]) – 
metadata (Optional[Dict[str, Any]]) – 
kwargs (Any) – 
Return type
str
async abatch(inputs: List[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]], config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Any) → List[str]¶
Default implementation runs ainvoke in parallel using asyncio.gather.
The default implementation of batch works well for IO bound runnables.
Subclasses should override this method if they can batch more efficiently;
e.g., if the underlying runnable uses an API which supports a batch mode.
Parameters
Parameters
input_type (Optional[Type[Input]]) – 
output_type (Optional[Type[Output]]) – 
Return type
Runnable[Input, Output]
property InputType: TypeAlias¶
Get the input type for this runnable.
property OutputType: Type[str]¶
Get the input type for this runnable.
property config_specs: List[ConfigurableFieldSpec]¶
List configurable fields for this runnable.
property input_schema: Type[BaseModel]¶
The type of input this runnable accepts specified as a pydantic model.
property lc_attributes: Dict¶
List of attribute names that should be included in the serialized kwargs.
These attributes must be accepted by the constructor.
property lc_secrets: Dict[str, str]¶
A map of constructor argument names to secret ids.
For example,{“openai_api_key”: “OPENAI_API_KEY”}
name: Optional[str] = None¶
The name of the runnable. Used for debugging and tracing.
property output_schema: Type[BaseModel]¶
The type of output this runnable produces specified as a pydantic model.
Examples using CloudflareWorkersAI¶
Cloudflare Workers AI
langchain_community.llms.aviary.AviaryBackend¶
class langchain_community.llms.aviary.AviaryBackend(backend_url: str, bearer: str)[source]¶
Aviary backend.
Parameters
backend_url (str) – 
bearer (str) – 
backend_url¶
The URL for the Aviary backend.
Type
str
bearer¶
The bearer token for the Aviary backend.
Type
str
Attributes
backend_url
bearer
Methods
__init__(backend_url, bearer)
from_env()
__init__(backend_url: str, bearer: str) → None¶
Parameters
backend_url (str) – 
bearer (str) – 
Return type
None
classmethod from_env() → AviaryBackend[source]¶
Return type
AviaryBackend
langchain_community.llms.bedrock.LLMInputOutputAdapter¶
class langchain_community.llms.bedrock.LLMInputOutputAdapter[source]¶
Adapter class to prepare the inputs from Langchain to a format
that LLM model expects.
It also provides helper function to extract
the generated text from the model response.
Attributes
provider_to_output_key_map
Methods
__init__()
aprepare_output_stream(provider, response[, ...])
prepare_input(provider, model_kwargs[, ...])
prepare_output(provider, response)
prepare_output_stream(provider, response[, ...])
__init__()¶
classmethod aprepare_output_stream(provider: str, response: Any, stop: Optional[List[str]] = None) → AsyncIterator[GenerationChunk][source]¶
Parameters
provider (str) – 
response (Any) – 
stop (Optional[List[str]]) – 
Return type
AsyncIterator[GenerationChunk]
classmethod prepare_input(provider: str, model_kwargs: Dict[str, Any], prompt: Optional[str] = None, system: Optional[str] = None, messages: Optional[List[Dict]] = None) → Dict[str, Any][source]¶
Parameters
provider (str) – 
model_kwargs (Dict[str, Any]) – 
prompt (Optional[str]) – 
system (Optional[str]) – 
messages (Optional[List[Dict]]) – 
Return type
Dict[str, Any]
classmethod prepare_output(provider: str, response: Any) → dict[source]¶
Parameters
provider (str) – 
response (Any) – 
Return type
dict
classmethod prepare_output_stream(provider: str, response: Any, stop: Optional[List[str]] = None, messages_api: bool = False) → Iterator[GenerationChunk][source]¶
Parameters
provider (str) – 
response (Any) –
langchain_experimental.llms.anthropic_functions.TagParser¶
class langchain_experimental.llms.anthropic_functions.TagParser[source]¶
Parser for the tool tags.
A heavy-handed solution, but it’s fast for prototyping.
Might be re-implemented later to restrict scope to the limited grammar, and
more efficiency.
Uses an HTML parser to parse a limited grammar that allows
for syntax of the form:
INPUT -> JUNK? VALUE*
JUNK -> JUNK_CHARACTER+
JUNK_CHARACTER -> whitespace | ,
VALUE -> <IDENTIFIER>DATA</IDENTIFIER> | OBJECT
OBJECT -> <IDENTIFIER>VALUE+</IDENTIFIER>
IDENTIFIER -> [a-Z][a-Z0-9_]*
DATA -> .*
Interprets the data to allow repetition of tags and recursion
to support representation of complex types.
^ Just another approximately wrong grammar specification.
Attributes
CDATA_CONTENT_ELEMENTS
Methods
__init__()
A heavy-handed solution, but it's fast for prototyping.
check_for_whole_start_tag(i)
clear_cdata_mode()
close()
Handle any buffered data.
feed(data)
Feed data to the parser.
get_starttag_text()
Return full source of start tag: '<...>'.
getpos()
Return current line number and offset.
goahead(end)
handle_charref(name)
handle_comment(data)
handle_data(data)
Hook when handling data.
handle_decl(decl)
handle_endtag(tag)
Hook when a tag is closed.
handle_entityref(name)
handle_pi(data)
handle_startendtag(tag, attrs)
handle_starttag(tag, attrs)
Hook when a new tag is encountered.
parse_bogus_comment(i[, report])
parse_comment(i[, report])
parse_declaration(i)
parse_endtag(i)
parse_comment(i[, report])
parse_declaration(i)
parse_endtag(i)
parse_html_declaration(i)
parse_marked_section(i[, report])
parse_pi(i)
parse_starttag(i)
reset()
Reset this instance.
set_cdata_mode(elem)
unknown_decl(data)
updatepos(i, j)
__init__() → None[source]¶
A heavy-handed solution, but it’s fast for prototyping.
Might be re-implemented later to restrict scope to the limited grammar, and
more efficiency.
Uses an HTML parser to parse a limited grammar that allows
for syntax of the form:
INPUT -> JUNK? VALUE*
JUNK -> JUNK_CHARACTER+
JUNK_CHARACTER -> whitespace | ,
VALUE -> <IDENTIFIER>DATA</IDENTIFIER> | OBJECT
OBJECT -> <IDENTIFIER>VALUE+</IDENTIFIER>
IDENTIFIER -> [a-Z][a-Z0-9_]*
DATA -> .*
Interprets the data to allow repetition of tags and recursion
to support representation of complex types.
^ Just another approximately wrong grammar specification.
Return type
None
check_for_whole_start_tag(i)¶
clear_cdata_mode()¶
close()¶
Handle any buffered data.
feed(data)¶
Feed data to the parser.
Call this as often as you want, with as little or as much text
as you want (may include ‘n’).
get_starttag_text()¶
Return full source of start tag: ‘<…>’.
getpos()¶
Return current line number and offset.
goahead(end)¶
handle_charref(name)¶
handle_comment(data)¶
handle_data(data: str) → None[source]¶
Hook when handling data.
Parameters
data (str) – 
Return type
None
handle_decl(decl)¶
data (str) – 
Return type
None
handle_decl(decl)¶
handle_endtag(tag: str) → None[source]¶
Hook when a tag is closed.
Parameters
tag (str) – 
Return type
None
handle_entityref(name)¶
handle_pi(data)¶
handle_startendtag(tag, attrs)¶
handle_starttag(tag: str, attrs: Any) → None[source]¶
Hook when a new tag is encountered.
Parameters
tag (str) – 
attrs (Any) – 
Return type
None
parse_bogus_comment(i, report=1)¶
parse_comment(i, report=1)¶
parse_declaration(i)¶
parse_endtag(i)¶
parse_html_declaration(i)¶
parse_marked_section(i, report=1)¶
parse_pi(i)¶
parse_starttag(i)¶
reset()¶
Reset this instance.  Loses all unprocessed data.
set_cdata_mode(elem)¶
unknown_decl(data)¶
updatepos(i, j)¶
langchain_community.llms.gooseai.GooseAI¶
class langchain_community.llms.gooseai.GooseAI[source]¶
Bases: LLM
GooseAI large language models.
To use, you should have the openai python package installed, and the
environment variable GOOSEAI_API_KEY set with your API key.
Any parameters that are valid to be passed to the openai.create call can be passed
in, even if not explicitly saved on this class.
Example
from langchain_community.llms import GooseAI
gooseai = GooseAI(model_name="gpt-neo-20b")
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 cache: Union[BaseCache, bool, None] = None¶
Whether to cache the response.
If true, will use the global cache.
If false, will not use a cache
If None, will use the global cache if it’s set, otherwise no cache.
If instance of BaseCache, will use the provided cache.
Caching is not currently supported for streaming methods of models.
param callback_manager: Optional[BaseCallbackManager] = None¶
[DEPRECATED]
param callbacks: Callbacks = None¶
Callbacks to add to the run trace.
param client: Any = None¶
param custom_get_token_ids: Optional[Callable[[str], List[int]]] = None¶
Optional encoder to use for counting tokens.
param frequency_penalty: float = 0¶
Penalizes repeated tokens according to frequency.
param gooseai_api_key: Optional[SecretStr] = None¶
Constraints
type = string
writeOnly = True
format = password
param logit_bias: Optional[Dict[str, float]] [Optional]¶
Adjust the probability of specific tokens being generated.
Adjust the probability of specific tokens being generated.
param max_tokens: int = 256¶
The maximum number of tokens to generate in the completion.
-1 returns as many tokens as possible given the prompt and
the models maximal context size.
param metadata: Optional[Dict[str, Any]] = None¶
Metadata to add to the run trace.
param min_tokens: int = 1¶
The minimum number of tokens to generate in the completion.
param model_kwargs: Dict[str, Any] [Optional]¶
Holds any model parameters valid for create call not explicitly specified.
param model_name: str = 'gpt-neo-20b'¶
Model name to use
param n: int = 1¶
How many completions to generate for each prompt.
param presence_penalty: float = 0¶
Penalizes repeated tokens.
param tags: Optional[List[str]] = None¶
Tags to add to the run trace.
param temperature: float = 0.7¶
What sampling temperature to use
param top_p: float = 1¶
Total probability mass of tokens to consider at each step.
param verbose: bool [Optional]¶
Whether to print out response text.
__call__(prompt: str, stop: Optional[List[str]] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs: Any) → str¶
[Deprecated] Check Cache and run the LLM on the given prompt and input.
Notes
Deprecated since version langchain-core==0.1.7: Use invoke instead.
Parameters
prompt (str) – 
stop (Optional[List[str]]) – 
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) –
Parameters
input_type (Optional[Type[Input]]) – 
output_type (Optional[Type[Output]]) – 
Return type
Runnable[Input, Output]
property InputType: TypeAlias¶
Get the input type for this runnable.
property OutputType: Type[str]¶
Get the input type for this runnable.
property config_specs: List[ConfigurableFieldSpec]¶
List configurable fields for this runnable.
property input_schema: Type[BaseModel]¶
The type of input this runnable accepts specified as a pydantic model.
property lc_attributes: Dict¶
List of attribute names that should be included in the serialized kwargs.
These attributes must be accepted by the constructor.
property lc_secrets: Dict[str, str]¶
A map of constructor argument names to secret ids.
For example,{“openai_api_key”: “OPENAI_API_KEY”}
name: Optional[str] = None¶
The name of the runnable. Used for debugging and tracing.
property output_schema: Type[BaseModel]¶
The type of output this runnable produces specified as a pydantic model.
Examples using GooseAI¶
GooseAI
langchain_community.llms.gigachat.GigaChat¶
class langchain_community.llms.gigachat.GigaChat[source]¶
Bases: _BaseGigaChat, BaseLLM
GigaChat large language models API.
To use, you should pass login and password to access GigaChat API or use token.
Example
from langchain_community.llms import GigaChat
giga = GigaChat(credentials=..., scope=..., verify_ssl_certs=False)
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 access_token: Optional[str] = None¶
Access token for GigaChat
param auth_url: Optional[str] = None¶
Auth URL
param base_url: Optional[str] = None¶
Base API URL
param ca_bundle_file: Optional[str] = None¶
param cache: Union[BaseCache, bool, None] = None¶
Whether to cache the response.
If true, will use the global cache.
If false, will not use a cache
If None, will use the global cache if it’s set, otherwise no cache.
If instance of BaseCache, will use the provided cache.
Caching is not currently supported for streaming methods of models.
param callback_manager: Optional[BaseCallbackManager] = None¶
[DEPRECATED]
param callbacks: Callbacks = None¶
Callbacks to add to the run trace.
param cert_file: Optional[str] = None¶
param credentials: Optional[str] = None¶
Auth Token
param custom_get_token_ids: Optional[Callable[[str], List[int]]] = None¶
Optional encoder to use for counting tokens.
param key_file: Optional[str] = None¶
param key_file_password: Optional[str] = None¶
param key_file_password: Optional[str] = None¶
param max_tokens: Optional[int] = None¶
Maximum number of tokens to generate
param metadata: Optional[Dict[str, Any]] = None¶
Metadata to add to the run trace.
param model: Optional[str] = None¶
Model name to use.
param password: Optional[str] = None¶
Password for authenticate
param payload_role: str = 'user'¶
param profanity: bool = True¶
DEPRECATED: Check for profanity
param profanity_check: Optional[bool] = None¶
Check for profanity
param repetition_penalty: Optional[float] = None¶
The penalty applied to repeated tokens
param scope: Optional[str] = None¶
Permission scope for access token
param streaming: bool = False¶
Whether to stream the results or not.
param tags: Optional[List[str]] = None¶
Tags to add to the run trace.
param temperature: Optional[float] = None¶
What sampling temperature to use.
param timeout: Optional[float] = None¶
Timeout for request
param top_p: Optional[float] = None¶
top_p value to use for nucleus sampling. Must be between 0.0 and 1.0
param update_interval: Optional[float] = None¶
Minimum interval in seconds that elapses between sending tokens
param use_api_for_tokens: bool = False¶
Use GigaChat API for tokens count
param user: Optional[str] = None¶
Username for authenticate
param verbose: bool = False¶
Verbose logging
param verify_ssl_certs: Optional[bool] = None¶
Check certificates for all requests
param verify_ssl_certs: Optional[bool] = None¶
Check certificates for all requests
__call__(prompt: str, stop: Optional[List[str]] = None, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs: Any) → str¶
[Deprecated] Check Cache and run the LLM on the given prompt and input.
Notes
Deprecated since version langchain-core==0.1.7: Use invoke instead.
Parameters
prompt (str) – 
stop (Optional[List[str]]) – 
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 
tags (Optional[List[str]]) – 
metadata (Optional[Dict[str, Any]]) – 
kwargs (Any) – 
Return type
str
async abatch(inputs: List[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]], config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Any) → List[str]¶
Default implementation runs ainvoke in parallel using asyncio.gather.
The default implementation of batch works well for IO bound runnables.
Subclasses should override this method if they can batch more efficiently;
e.g., if the underlying runnable uses an API which supports a batch mode.
Parameters
inputs (List[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]]) – 
config (Optional[Union[RunnableConfig, List[RunnableConfig]]]) – 
return_exceptions (bool) – 
kwargs (Any) –
Parameters
prompts (List[PromptValue]) – List of PromptValues. A PromptValue is an object that can be
converted to match the format of any language model (string for pure
text generation models and BaseMessages for chat models).
stop (Optional[List[str]]) – Stop words to use when generating. Model output is cut off at the
first occurrence of any of these substrings.
callbacks (Union[List[BaseCallbackHandler], BaseCallbackManager, None, List[Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]]]) – Callbacks to pass through. Used for executing additional
functionality, such as logging or streaming, throughout generation.
**kwargs (Any) – Arbitrary additional keyword arguments. These are usually passed
to the model provider API call.
Returns
An LLMResult, which contains a list of candidate Generations for each inputprompt and additional model provider-specific output.
Return type
LLMResult
async aget_model(model: str) → gm.Model¶
Get info about model (async)
Parameters
model (str) – 
Return type
gm.Model
async aget_models() → gm.Models¶
Get available models of Gigachat (async)
Return type
gm.Models
async ainvoke(input: Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]], config: Optional[RunnableConfig] = None, *, stop: Optional[List[str]] = None, **kwargs: Any) → str¶
Default implementation of ainvoke, calls invoke from a thread.
The default implementation allows usage of async code even if
the runnable did not implement a native async version of invoke.
Subclasses should override this method if they can run asynchronously.
Parameters
exclude_tags (Optional[Sequence[str]]) – Exclude logs with these tags.
kwargs (Any) – 
Return type
Union[AsyncIterator[RunLogPatch], AsyncIterator[RunLog]]
async atokens_count(input_: List[str], model: Optional[str] = None) → List[gm.TokensCount]¶
Get tokens of strings list (async)
Parameters
input_ (List[str]) – 
model (Optional[str]) – 
Return type
List[gm.TokensCount]
async atransform(input: AsyncIterator[Input], config: Optional[RunnableConfig] = None, **kwargs: Optional[Any]) → AsyncIterator[Output]¶
Default implementation of atransform, which buffers input and calls astream.
Subclasses should override this method if they can start producing output while
input is still being generated.
Parameters
input (AsyncIterator[Input]) – 
config (Optional[RunnableConfig]) – 
kwargs (Optional[Any]) – 
Return type
AsyncIterator[Output]
batch(inputs: List[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]], config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Any) → List[str]¶
Default implementation runs invoke in parallel using a thread pool executor.
The default implementation of batch works well for IO bound runnables.
Subclasses should override this method if they can batch more efficiently;
e.g., if the underlying runnable uses an API which supports a batch mode.
Parameters
inputs (List[Union[PromptValue, str, Sequence[Union[BaseMessage, List[str], Tuple[str, str], str, Dict[str, Any]]]]]) –
config (Optional[Union[RunnableConfig, List[RunnableConfig]]]) – 
return_exceptions (bool) – 
kwargs (Any) – 
Return type
List[str]
batch_as_completed(inputs: Sequence[Input], config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → Iterator[Tuple[int, Union[Output, Exception]]]¶
Run invoke in parallel on a list of inputs,
yielding results as they complete.
Parameters
inputs (Sequence[Input]) – 
config (Optional[Union[RunnableConfig, Sequence[RunnableConfig]]]) – 
return_exceptions (bool) – 
kwargs (Optional[Any]) – 
Return type
Iterator[Tuple[int, Union[Output, Exception]]]
bind(**kwargs: Any) → Runnable[Input, Output]¶
Bind arguments to a Runnable, returning a new Runnable.
Useful when a runnable in a chain requires an argument that is not
in the output of the previous runnable or included in the user input.
Example:
from langchain_community.chat_models import ChatOllama
from langchain_core.output_parsers import StrOutputParser
llm = ChatOllama(model='llama2')
# Without bind.
chain = (
    llm
    | StrOutputParser()
)
chain.invoke("Repeat quoted words exactly: 'One two three four five.'")
# Output is 'One two three four five.'
# With bind.
chain = (
    llm.bind(stop=["three"])
    | StrOutputParser()
)
chain.invoke("Repeat quoted words exactly: 'One two three four five.'")
# Output is 'One two'
Parameters
kwargs (Any) – 
Return type
Runnable[Input, Output]