initial commit

venv/Lib/site-packages/langchain_classic/chains/api/__init__.py

@@ -0,0 +1 @@
+"""Chain that makes API calls and summarizes the responses to answer a question."""

venv/Lib/site-packages/langchain_classic/chains/api/base.py

@@ -0,0 +1,399 @@
+"""Chain that makes API calls and summarizes the responses to answer a question."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+from urllib.parse import urlparse
+
+from langchain_core._api import deprecated
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForChainRun,
+    CallbackManagerForChainRun,
+)
+from langchain_core.language_models import BaseLanguageModel
+from langchain_core.prompts import BasePromptTemplate
+from pydantic import Field, model_validator
+from typing_extensions import Self
+
+from langchain_classic.chains.api.prompt import API_RESPONSE_PROMPT, API_URL_PROMPT
+from langchain_classic.chains.base import Chain
+from langchain_classic.chains.llm import LLMChain
+
+
+def _extract_scheme_and_domain(url: str) -> tuple[str, str]:
+    """Extract the scheme + domain from a given URL.
+
+    Args:
+        url: The input URL.
+
+    Returns:
+        A 2-tuple of scheme and domain
+    """
+    parsed_uri = urlparse(url)
+    return parsed_uri.scheme, parsed_uri.netloc
+
+
+def _check_in_allowed_domain(url: str, limit_to_domains: Sequence[str]) -> bool:
+    """Check if a URL is in the allowed domains.
+
+    Args:
+        url: The input URL.
+        limit_to_domains: The allowed domains.
+
+    Returns:
+        `True` if the URL is in the allowed domains, `False` otherwise.
+    """
+    scheme, domain = _extract_scheme_and_domain(url)
+
+    for allowed_domain in limit_to_domains:
+        allowed_scheme, allowed_domain_ = _extract_scheme_and_domain(allowed_domain)
+        if scheme == allowed_scheme and domain == allowed_domain_:
+            return True
+    return False
+
+
+try:
+    from langchain_community.utilities.requests import TextRequestsWrapper
+
+    @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.api.base.APIChain.html"
+        ),
+        removal="1.0",
+    )
+    class APIChain(Chain):
+        """Chain 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://docs.langchain.com/oss/python/security-policy 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:
+
+        ```bash
+        pip install -U langgraph
+        ```
+
+        ```python
+        from typing import Annotated, Sequence
+        from typing_extensions import TypedDict
+
+        from langchain_classic.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
+        \"\"\"
+
+        model = 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)
+            | model.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 model.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()
+        ```
+
+        ```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()
+        ```
+        """
+
+        api_request_chain: LLMChain
+
+        api_answer_chain: LLMChain
+
+        requests_wrapper: TextRequestsWrapper = Field(exclude=True)
+
+        api_docs: str
+
+        question_key: str = "question"
+
+        output_key: str = "output"
+
+        limit_to_domains: Sequence[str] | None = Field(default_factory=list)
+        """Use to limit the domains that can be accessed by the API chain.
+
+        * For example, to limit to just the domain `https://www.example.com`, set
+            `limit_to_domains=["https://www.example.com"]`.
+        * The default value is an empty tuple, which means that no domains are
+            allowed by default. By design this will raise an error on instantiation.
+        * Use a None if you want to allow all domains by default -- this is not
+            recommended for security reasons, as it would allow malicious users to
+            make requests to arbitrary URLS including internal APIs accessible from
+            the server.
+        """
+
+        @property
+        def input_keys(self) -> list[str]:
+            """Expect input key."""
+            return [self.question_key]
+
+        @property
+        def output_keys(self) -> list[str]:
+            """Expect output key."""
+            return [self.output_key]
+
+        @model_validator(mode="after")
+        def validate_api_request_prompt(self) -> Self:
+            """Check that api request prompt expects the right variables."""
+            input_vars = self.api_request_chain.prompt.input_variables
+            expected_vars = {"question", "api_docs"}
+            if set(input_vars) != expected_vars:
+                msg = f"Input variables should be {expected_vars}, got {input_vars}"
+                raise ValueError(msg)
+            return self
+
+        @model_validator(mode="before")
+        @classmethod
+        def validate_limit_to_domains(cls, values: dict) -> Any:
+            """Check that allowed domains are valid."""
+            # This check must be a pre=True check, so that a default of None
+            # won't be set to limit_to_domains if it's not provided.
+            if "limit_to_domains" not in values:
+                msg = (
+                    "You must specify a list of domains to limit access using "
+                    "`limit_to_domains`"
+                )
+                raise ValueError(msg)
+            if (
+                not values["limit_to_domains"]
+                and values["limit_to_domains"] is not None
+            ):
+                msg = (
+                    "Please provide a list of domains to limit access using "
+                    "`limit_to_domains`."
+                )
+                raise ValueError(msg)
+            return values
+
+        @model_validator(mode="after")
+        def validate_api_answer_prompt(self) -> Self:
+            """Check that api answer prompt expects the right variables."""
+            input_vars = self.api_answer_chain.prompt.input_variables
+            expected_vars = {"question", "api_docs", "api_url", "api_response"}
+            if set(input_vars) != expected_vars:
+                msg = f"Input variables should be {expected_vars}, got {input_vars}"
+                raise ValueError(msg)
+            return self
+
+        def _call(
+            self,
+            inputs: dict[str, Any],
+            run_manager: CallbackManagerForChainRun | None = None,
+        ) -> dict[str, str]:
+            _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
+            question = inputs[self.question_key]
+            api_url = self.api_request_chain.predict(
+                question=question,
+                api_docs=self.api_docs,
+                callbacks=_run_manager.get_child(),
+            )
+            _run_manager.on_text(api_url, color="green", end="\n", verbose=self.verbose)
+            api_url = api_url.strip()
+            if self.limit_to_domains and not _check_in_allowed_domain(
+                api_url,
+                self.limit_to_domains,
+            ):
+                msg = (
+                    f"{api_url} is not in the allowed domains: {self.limit_to_domains}"
+                )
+                raise ValueError(msg)
+            api_response = self.requests_wrapper.get(api_url)
+            _run_manager.on_text(
+                str(api_response),
+                color="yellow",
+                end="\n",
+                verbose=self.verbose,
+            )
+            answer = self.api_answer_chain.predict(
+                question=question,
+                api_docs=self.api_docs,
+                api_url=api_url,
+                api_response=api_response,
+                callbacks=_run_manager.get_child(),
+            )
+            return {self.output_key: answer}
+
+        async def _acall(
+            self,
+            inputs: dict[str, Any],
+            run_manager: AsyncCallbackManagerForChainRun | None = None,
+        ) -> dict[str, str]:
+            _run_manager = (
+                run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
+            )
+            question = inputs[self.question_key]
+            api_url = await self.api_request_chain.apredict(
+                question=question,
+                api_docs=self.api_docs,
+                callbacks=_run_manager.get_child(),
+            )
+            await _run_manager.on_text(
+                api_url,
+                color="green",
+                end="\n",
+                verbose=self.verbose,
+            )
+            api_url = api_url.strip()
+            if self.limit_to_domains and not _check_in_allowed_domain(
+                api_url,
+                self.limit_to_domains,
+            ):
+                msg = (
+                    f"{api_url} is not in the allowed domains: {self.limit_to_domains}"
+                )
+                raise ValueError(msg)
+            api_response = await self.requests_wrapper.aget(api_url)
+            await _run_manager.on_text(
+                str(api_response),
+                color="yellow",
+                end="\n",
+                verbose=self.verbose,
+            )
+            answer = await self.api_answer_chain.apredict(
+                question=question,
+                api_docs=self.api_docs,
+                api_url=api_url,
+                api_response=api_response,
+                callbacks=_run_manager.get_child(),
+            )
+            return {self.output_key: answer}
+
+        @classmethod
+        def from_llm_and_api_docs(
+            cls,
+            llm: BaseLanguageModel,
+            api_docs: str,
+            headers: dict | None = None,
+            api_url_prompt: BasePromptTemplate = API_URL_PROMPT,
+            api_response_prompt: BasePromptTemplate = API_RESPONSE_PROMPT,
+            limit_to_domains: Sequence[str] | None = (),
+            **kwargs: Any,
+        ) -> APIChain:
+            """Load chain from just an LLM and the api docs."""
+            get_request_chain = LLMChain(llm=llm, prompt=api_url_prompt)
+            requests_wrapper = TextRequestsWrapper(headers=headers)
+            get_answer_chain = LLMChain(llm=llm, prompt=api_response_prompt)
+            return cls(
+                api_request_chain=get_request_chain,
+                api_answer_chain=get_answer_chain,
+                requests_wrapper=requests_wrapper,
+                api_docs=api_docs,
+                limit_to_domains=limit_to_domains,
+                **kwargs,
+            )
+
+        @property
+        def _chain_type(self) -> str:
+            return "api_chain"
+
+except ImportError:
+
+    class APIChain:  # type: ignore[no-redef]
+        """Raise an ImportError if APIChain is used without langchain_community."""
+
+        def __init__(self, *_: Any, **__: Any) -> None:
+            """Raise an ImportError if APIChain is used without langchain_community."""
+            msg = (
+                "To use the APIChain, you must install the langchain_community package."
+                "pip install langchain_community"
+            )
+            raise ImportError(msg)

venv/Lib/site-packages/langchain_classic/chains/api/news_docs.py

@@ -0,0 +1,31 @@
+NEWS_DOCS = """API documentation:
+Endpoint: https://newsapi.org
+Top headlines /v2/top-headlines
+
+This endpoint provides live top and breaking headlines for a country, specific category in a country, single source, or multiple sources. You can also search with keywords. Articles are sorted by the earliest date published first.
+
+This endpoint is great for retrieving headlines for use with news tickers or similar.
+Request parameters
+
+    country | The 2-letter ISO 3166-1 code of the country you want to get headlines for. Possible options: ae ar at au be bg br ca ch cn co cu cz de eg fr gb gr hk hu id ie il in it jp kr lt lv ma mx my ng nl no nz ph pl pt ro rs ru sa se sg si sk th tr tw ua us ve za. Note: you can't mix this param with the sources param.
+    category | The category you want to get headlines for. Possible options: business entertainment general health science sports technology. Note: you can't mix this param with the sources param.
+    sources | A comma-separated string of identifiers for the news sources or blogs you want headlines from. Use the /top-headlines/sources endpoint to locate these programmatically or look at the sources index. Note: you can't mix this param with the country or category params.
+    q | Keywords or a phrase to search for.
+    pageSize | int | The number of results to return per page (request). 20 is the default, 100 is the maximum.
+    page | int | Use this to page through the results if the total results found is greater than the page size.
+
+Response object
+    status | string | If the request was successful or not. Options: ok, error. In the case of error a code and message property will be populated.
+    totalResults | int | The total number of results available for your request.
+    articles | array[article] | The results of the request.
+    source | object | The identifier id and a display name name for the source this article came from.
+    author | string | The author of the article
+    title | string | The headline or title of the article.
+    description | string | A description or snippet from the article.
+    url | string | The direct URL to the article.
+    urlToImage | string | The URL to a relevant image for the article.
+    publishedAt | string | The date and time that the article was published, in UTC (+000)
+    content | string | The unformatted content of the article, where available. This is truncated to 200 chars.
+
+Use page size: 2
+"""  # noqa: E501

venv/Lib/site-packages/langchain_classic/chains/api/open_meteo_docs.py

@@ -0,0 +1,32 @@
+OPEN_METEO_DOCS = """BASE URL: https://api.open-meteo.com/
+
+API Documentation
+The API endpoint /v1/forecast accepts a geographical coordinate, a list of weather variables and responds with a JSON hourly weather forecast for 7 days. Time always starts at 0:00 today and contains 168 hours. All URL parameters are listed below:
+
+Parameter	Format	Required	Default	Description
+latitude, longitude	Floating point	Yes		Geographical WGS84 coordinate of the location
+hourly	String array	No		A list of weather variables which should be returned. Values can be comma separated, or multiple &hourly= parameter in the URL can be used.
+daily	String array	No		A list of daily weather variable aggregations which should be returned. Values can be comma separated, or multiple &daily= parameter in the URL can be used. If daily weather variables are specified, parameter timezone is required.
+current_weather	Bool	No	false	Include current weather conditions in the JSON output.
+temperature_unit	String	No	celsius	If fahrenheit is set, all temperature values are converted to Fahrenheit.
+windspeed_unit	String	No	kmh	Other wind speed speed units: ms, mph and kn
+precipitation_unit	String	No	mm	Other precipitation amount units: inch
+timeformat	String	No	iso8601	If format unixtime is selected, all time values are returned in UNIX epoch time in seconds. Please note that all timestamp are in GMT+0! For daily values with unix timestamps, please apply utc_offset_seconds again to get the correct date.
+timezone	String	No	GMT	If timezone is set, all timestamps are returned as local-time and data is returned starting at 00:00 local-time. Any time zone name from the time zone database is supported. If auto is set as a time zone, the coordinates will be automatically resolved to the local time zone.
+past_days	Integer (0-2)	No	0	If past_days is set, yesterday or the day before yesterday data are also returned.
+start_date
+end_date	String (yyyy-mm-dd)	No		The time interval to get weather data. A day must be specified as an ISO8601 date (e.g. 2022-06-30).
+models	String array	No	auto	Manually select one or more weather models. Per default, the best suitable weather models will be combined.
+
+Hourly Parameter Definition
+The parameter &hourly= accepts the following values. Most weather variables are given as an instantaneous value for the indicated hour. Some variables like precipitation are calculated from the preceding hour as an average or sum.
+
+Variable	Valid time	Unit	Description
+temperature_2m	Instant	°C (°F)	Air temperature at 2 meters above ground
+snowfall	Preceding hour sum	cm (inch)	Snowfall amount of the preceding hour in centimeters. For the water equivalent in millimeter, divide by 7. E.g. 7 cm snow = 10 mm precipitation water equivalent
+rain	Preceding hour sum	mm (inch)	Rain from large scale weather systems of the preceding hour in millimeter
+showers	Preceding hour sum	mm (inch)	Showers from convective precipitation in millimeters from the preceding hour
+weathercode	Instant	WMO code	Weather condition as a numeric code. Follow WMO weather interpretation codes. See table below for details.
+snow_depth	Instant	meters	Snow depth on the ground
+freezinglevel_height	Instant	meters	Altitude above sea level of the 0°C level
+visibility	Instant	meters	Viewing distance in meters. Influenced by low clouds, humidity and aerosols. Maximum visibility is approximately 24 km."""  # noqa: E501

venv/Lib/site-packages/langchain_classic/chains/api/openapi/chain.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.chains.openapi.chain import OpenAPIEndpointChain
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "OpenAPIEndpointChain": "langchain_community.chains.openapi.chain",
+}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = ["OpenAPIEndpointChain"]

venv/Lib/site-packages/langchain_classic/chains/api/openapi/prompts.py

@@ -0,0 +1,27 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.chains.openapi.prompts import (
+        REQUEST_TEMPLATE,
+        RESPONSE_TEMPLATE,
+    )
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "REQUEST_TEMPLATE": "langchain_community.chains.openapi.prompts",
+    "RESPONSE_TEMPLATE": "langchain_community.chains.openapi.prompts",
+}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = ["REQUEST_TEMPLATE", "RESPONSE_TEMPLATE"]

venv/Lib/site-packages/langchain_classic/chains/api/openapi/requests_chain.py

@@ -0,0 +1,29 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.chains.openapi.requests_chain import (
+        REQUEST_TEMPLATE,
+        APIRequesterChain,
+        APIRequesterOutputParser,
+    )
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "APIRequesterChain": "langchain_community.chains.openapi.requests_chain",
+    "APIRequesterOutputParser": "langchain_community.chains.openapi.requests_chain",
+    "REQUEST_TEMPLATE": "langchain_community.chains.openapi.requests_chain",
+}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = ["REQUEST_TEMPLATE", "APIRequesterChain", "APIRequesterOutputParser"]

venv/Lib/site-packages/langchain_classic/chains/api/openapi/response_chain.py

@@ -0,0 +1,29 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.chains.openapi.response_chain import (
+        RESPONSE_TEMPLATE,
+        APIResponderChain,
+        APIResponderOutputParser,
+    )
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "APIResponderChain": "langchain_community.chains.openapi.response_chain",
+    "APIResponderOutputParser": "langchain_community.chains.openapi.response_chain",
+    "RESPONSE_TEMPLATE": "langchain_community.chains.openapi.response_chain",
+}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = ["RESPONSE_TEMPLATE", "APIResponderChain", "APIResponderOutputParser"]

venv/Lib/site-packages/langchain_classic/chains/api/podcast_docs.py

@@ -0,0 +1,27 @@
+PODCAST_DOCS = """API documentation:
+Endpoint: https://listen-api.listennotes.com/api/v2
+GET /search
+
+This API is for searching podcasts or episodes.
+
+Query parameters table:
+q | string | Search term, e.g., person, place, topic... You can use double quotes to do verbatim match, e.g., "game of thrones". Otherwise, it's fuzzy search. | required
+type | string | What type of contents do you want to search for? Available values: episode, podcast, curated. default: episode | optional
+page_size | integer | The maximum number of search results per page. A valid value should be an integer between 1 and 10 (inclusive). default: 3 | optional
+language | string | Limit search results to a specific language, e.g., English, Chinese ... If not specified, it'll be any language. It works only when type is episode or podcast. | optional
+region | string | Limit search results to a specific region (e.g., us, gb, in...). If not specified, it'll be any region. It works only when type is episode or podcast. | optional
+len_min | integer | Minimum audio length in minutes. Applicable only when type parameter is episode or podcast. If type parameter is episode, it's for audio length of an episode. If type parameter is podcast, it's for average audio length of all episodes in a podcast. | optional
+len_max | integer | Maximum audio length in minutes. Applicable only when type parameter is episode or podcast. If type parameter is episode, it's for audio length of an episode. If type parameter is podcast, it's for average audio length of all episodes in a podcast. | optional
+
+Response schema (JSON object):
+next_offset | integer | optional
+total | integer | optional
+results | array[object] (Episode / Podcast List Result Object)
+
+Each object in the "results" key has the following schema:
+listennotes_url | string | optional
+id | integer | optional
+title_highlighted | string | optional
+
+Use page_size: 3
+"""  # noqa: E501

venv/Lib/site-packages/langchain_classic/chains/api/prompt.py

@@ -0,0 +1,35 @@
+from langchain_core.prompts.prompt import PromptTemplate
+
+API_URL_PROMPT_TEMPLATE = """You are given the below API Documentation:
+{api_docs}
+Using this documentation, generate the full API url to call for answering the user question.
+You should build the API url in order to get a response that is as short as possible, while still getting the necessary information to answer the question. Pay attention to deliberately exclude any unnecessary pieces of data in the API call.
+
+Question:{question}
+API url:"""  # noqa: E501
+
+API_URL_PROMPT = PromptTemplate(
+    input_variables=[
+        "api_docs",
+        "question",
+    ],
+    template=API_URL_PROMPT_TEMPLATE,
+)
+
+API_RESPONSE_PROMPT_TEMPLATE = (
+    API_URL_PROMPT_TEMPLATE
+    + """ {api_url}
+
+Here is the response from the API:
+
+{api_response}
+
+Summarize this response to answer the original question.
+
+Summary:"""
+)
+
+API_RESPONSE_PROMPT = PromptTemplate(
+    input_variables=["api_docs", "question", "api_url", "api_response"],
+    template=API_RESPONSE_PROMPT_TEMPLATE,
+)

venv/Lib/site-packages/langchain_classic/chains/api/tmdb_docs.py

@@ -0,0 +1,36 @@
+TMDB_DOCS = """API documentation:
+Endpoint: https://api.themoviedb.org/3
+GET /search/movie
+
+This API is for searching movies.
+
+Query parameters table:
+language | string | Pass a ISO 639-1 value to display translated data for the fields that support it. minLength: 2, pattern: ([a-z]{2})-([A-Z]{2}), default: en-US | optional
+query | string | Pass a text query to search. This value should be URI encoded. minLength: 1 | required
+page | integer | Specify which page to query. minimum: 1, maximum: 1000, default: 1 | optional
+include_adult | boolean | Choose whether to include adult (pornography) content in the results. default | optional
+region | string | Specify a ISO 3166-1 code to filter release dates. Must be uppercase. pattern: ^[A-Z]{2}$ | optional
+year | integer  | optional
+primary_release_year | integer | optional
+
+Response schema (JSON object):
+page | integer | optional
+total_results | integer | optional
+total_pages | integer | optional
+results | array[object] (Movie List Result Object)
+
+Each object in the "results" key has the following schema:
+poster_path | string or null | optional
+adult | boolean | optional
+overview | string | optional
+release_date | string | optional
+genre_ids | array[integer] | optional
+id | integer | optional
+original_title | string | optional
+original_language | string | optional
+title | string | optional
+backdrop_path | string or null | optional
+popularity | number | optional
+vote_count | integer | optional
+video | boolean | optional
+vote_average | number | optional"""  # noqa: E501