HEX

File: //usr/local/lib/python3.10/dist-packages/langchain/chains/api/__pycache__/base.cpython-310.pyc
o

���g�;�@sdZddlmZddlmZmZmZmZmZm	Z	ddl
mZddlm
Z
ddlmZmZddlmZddlmZdd	lmZmZdd
lmZddlmZmZddlmZdd
lm Z d"dd�Z!d#dd�Z"zddl#m$Z$e
dddd�Gdd�de��Z%Wd!Se&y�Gd d�d�Z%Yd!Sw)$zMChain that makes API calls and summarizes the responses to answer a question.�)�annotations)�Any�Dict�List�Optional�Sequence�Tuple)�urlparse)�
deprecated)�AsyncCallbackManagerForChainRun�CallbackManagerForChainRun)�BaseLanguageModel)�BasePromptTemplate)�Field�model_validator)�Self)�API_RESPONSE_PROMPT�API_URL_PROMPT)�Chain)�LLMChain�url�str�return�Tuple[str, str]cCst|�}|j|jfS)z�Extract the scheme + domain from a given URL.

    Args:
        url (str): The input URL.

    Returns:
        return a 2-tuple of scheme and domain
    )r	�scheme�netloc)r�
parsed_uri�r�D/usr/local/lib/python3.10/dist-packages/langchain/chains/api/base.py�_extract_scheme_and_domains	r�limit_to_domains�
Sequence[str]�boolcCs<t|�\}}|D]}t|�\}}||kr||krdSqdS)z�Check if a URL is in the allowed domains.

    Args:
        url (str): The input URL.
        limit_to_domains (Sequence[str]): The allowed domains.

    Returns:
        bool: True if the URL is in the allowed domains, False otherwise.
    TF)r)rr r�domain�allowed_domain�allowed_schemerrr�_check_in_allowed_domain$s
�r&)�TextRequestsWrapperz0.2.13z�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.api.base.APIChain.htmlz1.0)�since�message�removalc@seZdZUdZded<ded<edd�Zded<d	ed
<dZd	ed<d
Zd	ed<ee	d�Z
ded<	ed<dd��Zed<dd��Z
edd�d=dd��Zedd�ed>d!d"���Zedd�d=d#d$��Z	%d?d@d+d,�Z	%d?dAd.d/�Zed%eee�fdBd8d9��ZedCd:d;��Zd%S)D�APIChainaChain that makes API calls and summarizes the responses to answer a question.

        *Security Note*: This API chain uses the requests toolkit
            to make GET, POST, PATCH, PUT, and DELETE requests to an API.

            Exercise care in who is allowed to use this chain. If exposing
            to end users, consider that users will be able to make arbitrary
            requests on behalf of the server hosting the code. For example,
            users could ask the server to make a request to a private API
            that is only accessible from the server.

            Control access to who can submit issue requests using this toolkit and
            what network access it has.

            See https://python.langchain.com/docs/security for more information.

        Note: this class is deprecated. See below for a replacement implementation
        using LangGraph. The benefits of this implementation are:

        - Uses LLM tool calling features to encourage properly-formatted API requests;
        - 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 Annotated, Sequence
            from typing_extensions import TypedDict

            from langchain.chains.api.prompt import API_URL_PROMPT
            from langchain_community.agent_toolkits.openapi.toolkit import RequestsToolkit
            from langchain_community.utilities.requests import TextRequestsWrapper
            from langchain_core.messages import BaseMessage
            from langchain_core.prompts import ChatPromptTemplate
            from langchain_openai import ChatOpenAI
            from langchain_core.runnables import RunnableConfig
            from langgraph.graph import END, StateGraph
            from langgraph.graph.message import add_messages
            from langgraph.prebuilt.tool_node import ToolNode

            # NOTE: There are inherent risks in giving models discretion
            # to execute real-world actions. We must "opt-in" to these
            # risks by setting allow_dangerous_request=True to use these tools.
            # This can be dangerous for calling unwanted requests. Please make
            # sure your custom OpenAPI spec (yaml) is safe and that permissions
            # associated with the tools are narrowly-scoped.
            ALLOW_DANGEROUS_REQUESTS = True

            # Subset of spec for https://jsonplaceholder.typicode.com
            api_spec = """
            openapi: 3.0.0
            info:
              title: JSONPlaceholder API
              version: 1.0.0
            servers:
              - url: https://jsonplaceholder.typicode.com
            paths:
              /posts:
                get:
                  summary: Get posts
                  parameters: &id001
                    - name: _limit
                      in: query
                      required: false
                      schema:
                        type: integer
                      example: 2
                      description: Limit the number of results
            """

            llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
            toolkit = RequestsToolkit(
                requests_wrapper=TextRequestsWrapper(headers={}),  # no auth required
                allow_dangerous_requests=ALLOW_DANGEROUS_REQUESTS,
            )
            tools = toolkit.get_tools()

            api_request_chain = (
                API_URL_PROMPT.partial(api_docs=api_spec)
                | llm.bind_tools(tools, tool_choice="any")
            )

            class ChainState(TypedDict):
                """LangGraph state."""

                messages: Annotated[Sequence[BaseMessage], add_messages]


            async def acall_request_chain(state: ChainState, config: RunnableConfig):
                last_message = state["messages"][-1]
                response = await api_request_chain.ainvoke(
                    {"question": last_message.content}, config
                )
                return {"messages": [response]}

            async def acall_model(state: ChainState, config: RunnableConfig):
                response = await llm.ainvoke(state["messages"], config)
                return {"messages": [response]}

            graph_builder = StateGraph(ChainState)
            graph_builder.add_node("call_tool", acall_request_chain)
            graph_builder.add_node("execute_tool", ToolNode(tools))
            graph_builder.add_node("call_model", acall_model)
            graph_builder.set_entry_point("call_tool")
            graph_builder.add_edge("call_tool", "execute_tool")
            graph_builder.add_edge("execute_tool", "call_model")
            graph_builder.add_edge("call_model", END)
            chain = graph_builder.compile()

        .. code-block:: python

            example_query = "Fetch the top two posts. What are their titles?"

            events = chain.astream(
                {"messages": [("user", example_query)]},
                stream_mode="values",
            )
            async for event in events:
                event["messages"][-1].pretty_print()
        r�api_request_chain�api_answer_chainT)�excluder'�requests_wrapperr�api_docs�question�question_key�output�
output_key)�default_factory�Optional[Sequence[str]]r r�	List[str]cC�|jgS)z:Expect input key.

            :meta private:
            )r2��selfrrr�
input_keys��zAPIChain.input_keyscCr8)z;Expect output key.

            :meta private:
            )r4r9rrr�output_keys�r<zAPIChain.output_keys�after)�modercCs6|jjj}ddh}t|�|krtd|�d|����|S)z:Check that api request prompt expects the right variables.r1r0�Input variables should be �, got )r,�prompt�input_variables�set�
ValueError�r:�
input_vars�
expected_varsrrr�validate_api_request_prompt��
�z$APIChain.validate_api_request_prompt�before�valuesrrcCs0d|vrtd��|ds|ddurtd��|S)z%Check that allowed domains are valid.r zKYou must specify a list of domains to limit access using `limit_to_domains`NzJPlease provide a list of domains to limit access using `limit_to_domains`.)rE)�clsrLrrr�validate_limit_to_domains�s���z"APIChain.validate_limit_to_domainscCs6|jjj}hd�}t|�|krtd|�d|����|S)z9Check that api answer prompt expects the right variables.>�api_urlr0r1�api_responser@rA)r-rBrCrDrErFrrr�validate_api_answer_prompt	rJz#APIChain.validate_api_answer_promptN�inputs�Dict[str, Any]�run_manager�$Optional[CallbackManagerForChainRun]�Dict[str, str]cCs�|pt��}||j}|jj||j|��d�}|j|dd|jd�|�	�}|j
r8t||j
�s8t|�d|j
����|j
�|�}|jt|�dd|jd�|jj||j|||��d�}|j|iS�N)r1r0�	callbacks�green�
)�color�end�verbosez  is not in the allowed domains: �yellow)r1r0rOrPrX)r�get_noop_managerr2r,�predictr0�	get_child�on_textr]�stripr r&rEr/�getrr-r4�r:rRrT�_run_managerr1rOrP�answerrrr�_calls6
�����
zAPIChain._call�)Optional[AsyncCallbackManagerForChainRun]c�s��|pt��}||j}|jj||j|��d�IdH}|j|dd|jd�IdH|�	�}|j
r?t||j
�s?t|�d|j
����|j
�|�IdH}|jt|�dd|jd�IdH|jj||j|||��d�IdH}|j|iSrW)rr_r2r,�apredictr0rarbr]rcr r&rEr/�agetrr-r4rerrr�_acall5s>�
�
�
�����
zAPIChain._acall�llmr
�headers�Optional[dict]�api_url_promptr�api_response_prompt�kwargscKs<t||d�}t|d�}	t||d�}
|d||
|	||d�|��S)z-Load chain from just an LLM and the api docs.)rmrB)rn)r,r-r/r0r Nr)rr')rMrmr0rnrprqr rr�get_request_chainr/�get_answer_chainrrr�from_llm_and_api_docsZs
��zAPIChain.from_llm_and_api_docscCsdS)N�	api_chainrr9rrr�_chain_typerszAPIChain._chain_type)rr7)rr)rLrrr)N)rRrSrTrUrrV)rRrSrTrirrV)rmr
r0rrnrorprrqrr r6rrrrr+)rr)�__name__�
__module__�__qualname__�__doc__�__annotations__rr/r2r4�listr �propertyr;r=rrI�classmethodrNrQrhrlrr�tuplerurwrrrrr+:sF

�


�$�%�r+c@seZdZd	dd�ZdS)
r+�argsrrrr�NonecOstd��)NzeTo use the APIChain, you must install the langchain_community package.pip install langchain_community)�ImportError)r:r�rrrrr�__init__ys�zAPIChain.__init__N)r�rrrrrr�)rxryrzr�rrrrr+xsN)rrrr)rrr r!rr")'r{�
__future__r�typingrrrrrr�urllib.parser	�langchain_core._apir
�langchain_core.callbacksrr�langchain_core.language_modelsr
�langchain_core.promptsr�pydanticrr�typing_extensionsr�langchain.chains.api.promptrr�langchain.chains.baser�langchain.chains.llmrrr&�&langchain_community.utilities.requestsr'r+r�rrrr�<module>s8 


�	5�