langchain 0.4.0.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

langchain/chains/openai_functions/base.py

@@ -1,237 +0,0 @@
-"""Methods for creating chains that use OpenAI function-calling APIs."""
-
-from collections.abc import Sequence
-from typing import (
-    Any,
-    Callable,
-    Optional,
-    Union,
-)
-
-from langchain_core._api import deprecated
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers import (
-    BaseLLMOutputParser,
-)
-from langchain_core.output_parsers.openai_functions import (
-    PydanticAttrOutputFunctionsParser,
-)
-from langchain_core.prompts import BasePromptTemplate
-from langchain_core.utils.function_calling import (
-    PYTHON_TO_JSON_TYPES,
-    convert_to_openai_function,
-)
-from pydantic import BaseModel
-
-from langchain.chains import LLMChain
-from langchain.chains.structured_output.base import (
-    create_openai_fn_runnable,
-    create_structured_output_runnable,
-    get_openai_output_parser,
-)
-
-__all__ = [
-    "PYTHON_TO_JSON_TYPES",  # backwards compatibility
-    "convert_to_openai_function",  # backwards compatibility
-    "create_openai_fn_chain",  # deprecated
-    "create_openai_fn_runnable",
-    "create_structured_output_chain",  # deprecated
-    "create_structured_output_runnable",  # deprecated
-    "get_openai_output_parser",
-]
-
-
-@deprecated(since="0.1.1", removal="1.0", alternative="create_openai_fn_runnable")
-def create_openai_fn_chain(
-    functions: Sequence[Union[dict[str, Any], type[BaseModel], Callable]],
-    llm: BaseLanguageModel,
-    prompt: BasePromptTemplate,
-    *,
-    enforce_single_function_usage: bool = True,
-    output_key: str = "function",
-    output_parser: Optional[BaseLLMOutputParser] = None,
-    **kwargs: Any,
-) -> LLMChain:
-    """[Legacy] Create an LLM chain that uses OpenAI functions.
-
-    Args:
-        functions: A sequence of either dictionaries, pydantic.BaseModels classes, or
-            Python functions. If dictionaries are passed in, they are assumed to
-            already be a valid OpenAI functions. If only a single
-            function is passed in, then it will be enforced that the model use that
-            function. pydantic.BaseModels and Python functions should have docstrings
-            describing what the function does. For best results, pydantic.BaseModels
-            should have descriptions of the parameters and Python functions should have
-            Google Python style args descriptions in the docstring. Additionally,
-            Python functions should only use primitive types (str, int, float, bool) or
-            pydantic.BaseModels for arguments.
-        llm: Language model to use, assumed to support the OpenAI function-calling API.
-        prompt: BasePromptTemplate to pass to the model.
-        enforce_single_function_usage: only used if a single function is passed in. If
-            True, then the model will be forced to use the given function. If False,
-            then the model will be given the option to use the given function or not.
-        output_key: The key to use when returning the output in LLMChain.__call__.
-        output_parser: BaseLLMOutputParser to use for parsing model outputs. By default
-            will be inferred from the function types. If pydantic.BaseModels are passed
-            in, then the OutputParser will try to parse outputs using those. Otherwise
-            model outputs will simply be parsed as JSON. If multiple functions are
-            passed in and they are not pydantic.BaseModels, the chain output will
-            include both the name of the function that was returned and the arguments
-            to pass to the function.
-
-    Returns:
-        An LLMChain that will pass in the given functions to the model when run.
-
-    Example:
-        .. code-block:: python
-
-                from typing import Optional
-
-                from langchain.chains.openai_functions import create_openai_fn_chain
-                from langchain_community.chat_models import ChatOpenAI
-                from langchain_core.prompts import ChatPromptTemplate
-
-                from pydantic import BaseModel, Field
-
-
-                class RecordPerson(BaseModel):
-                    \"\"\"Record some identifying information about a person.\"\"\"
-
-                    name: str = Field(..., description="The person's name")
-                    age: int = Field(..., description="The person's age")
-                    fav_food: Optional[str] = Field(None, description="The person's favorite food")
-
-
-                class RecordDog(BaseModel):
-                    \"\"\"Record some identifying information about a dog.\"\"\"
-
-                    name: str = Field(..., description="The dog's name")
-                    color: str = Field(..., description="The dog's color")
-                    fav_food: Optional[str] = Field(None, description="The dog's favorite food")
-
-
-                llm = ChatOpenAI(model="gpt-4", temperature=0)
-                prompt = ChatPromptTemplate.from_messages(
-                    [
-                        ("system", "You are a world class algorithm for recording entities."),
-                        ("human", "Make calls to the relevant function to record the entities in the following input: {input}"),
-                        ("human", "Tip: Make sure to answer in the correct format"),
-                    ]
-                )
-                chain = create_openai_fn_chain([RecordPerson, RecordDog], llm, prompt)
-                chain.run("Harry was a chubby brown beagle who loved chicken")
-                # -> RecordDog(name="Harry", color="brown", fav_food="chicken")
-
-    """  # noqa: E501
-    if not functions:
-        msg = "Need to pass in at least one function. Received zero."
-        raise ValueError(msg)
-    openai_functions = [convert_to_openai_function(f) for f in functions]
-    output_parser = output_parser or get_openai_output_parser(functions)
-    llm_kwargs: dict[str, Any] = {
-        "functions": openai_functions,
-    }
-    if len(openai_functions) == 1 and enforce_single_function_usage:
-        llm_kwargs["function_call"] = {"name": openai_functions[0]["name"]}
-    return LLMChain(
-        llm=llm,
-        prompt=prompt,
-        output_parser=output_parser,
-        llm_kwargs=llm_kwargs,
-        output_key=output_key,
-        **kwargs,
-    )
-
-
-@deprecated(
-    since="0.1.1",
-    removal="1.0",
-    alternative="ChatOpenAI.with_structured_output",
-)
-def create_structured_output_chain(
-    output_schema: Union[dict[str, Any], type[BaseModel]],
-    llm: BaseLanguageModel,
-    prompt: BasePromptTemplate,
-    *,
-    output_key: str = "function",
-    output_parser: Optional[BaseLLMOutputParser] = None,
-    **kwargs: Any,
-) -> LLMChain:
-    """[Legacy] Create an LLMChain that uses an OpenAI function to get a structured output.
-
-    Args:
-        output_schema: Either a dictionary or pydantic.BaseModel class. If a dictionary
-            is passed in, it's assumed to already be a valid JsonSchema.
-            For best results, pydantic.BaseModels should have docstrings describing what
-            the schema represents and descriptions for the parameters.
-        llm: Language model to use, assumed to support the OpenAI function-calling API.
-        prompt: BasePromptTemplate to pass to the model.
-        output_key: The key to use when returning the output in LLMChain.__call__.
-        output_parser: BaseLLMOutputParser to use for parsing model outputs. By default
-            will be inferred from the function types. If pydantic.BaseModels are passed
-            in, then the OutputParser will try to parse outputs using those. Otherwise
-            model outputs will simply be parsed as JSON.
-
-    Returns:
-        An LLMChain that will pass the given function to the model.
-
-    Example:
-        .. code-block:: python
-
-                from typing import Optional
-
-                from langchain.chains.openai_functions import create_structured_output_chain
-                from langchain_community.chat_models import ChatOpenAI
-                from langchain_core.prompts import ChatPromptTemplate
-
-                from pydantic import BaseModel, Field
-
-                class Dog(BaseModel):
-                    \"\"\"Identifying information about a dog.\"\"\"
-
-                    name: str = Field(..., description="The dog's name")
-                    color: str = Field(..., description="The dog's color")
-                    fav_food: Optional[str] = Field(None, description="The dog's favorite food")
-
-                llm = ChatOpenAI(model="gpt-3.5-turbo-0613", temperature=0)
-                prompt = ChatPromptTemplate.from_messages(
-                    [
-                        ("system", "You are a world class algorithm for extracting information in structured formats."),
-                        ("human", "Use the given format to extract information from the following input: {input}"),
-                        ("human", "Tip: Make sure to answer in the correct format"),
-                    ]
-                )
-                chain = create_structured_output_chain(Dog, llm, prompt)
-                chain.run("Harry was a chubby brown beagle who loved chicken")
-                # -> Dog(name="Harry", color="brown", fav_food="chicken")
-
-    """  # noqa: E501
-    if isinstance(output_schema, dict):
-        function: Any = {
-            "name": "output_formatter",
-            "description": (
-                "Output formatter. Should always be used to format your response to the"
-                " user."
-            ),
-            "parameters": output_schema,
-        }
-    else:
-
-        class _OutputFormatter(BaseModel):
-            """Output formatter. Should always be used to format your response to the user."""  # noqa: E501
-
-            output: output_schema  # type: ignore[valid-type]
-
-        function = _OutputFormatter
-        output_parser = output_parser or PydanticAttrOutputFunctionsParser(
-            pydantic_schema=_OutputFormatter,
-            attr_name="output",
-        )
-    return create_openai_fn_chain(
-        [function],
-        llm,
-        prompt,
-        output_key=output_key,
-        output_parser=output_parser,
-        **kwargs,
-    )

langchain/chains/openai_functions/citation_fuzzy_match.py

@@ -1,169 +0,0 @@
-from collections.abc import Iterator
-
-from langchain_core._api import deprecated
-from langchain_core.language_models import BaseChatModel, BaseLanguageModel
-from langchain_core.messages import HumanMessage, SystemMessage
-from langchain_core.output_parsers.openai_functions import PydanticOutputFunctionsParser
-from langchain_core.prompts.chat import ChatPromptTemplate, HumanMessagePromptTemplate
-from langchain_core.runnables import Runnable
-from pydantic import BaseModel, Field
-
-from langchain.chains.llm import LLMChain
-from langchain.chains.openai_functions.utils import get_llm_kwargs
-
-
-class FactWithEvidence(BaseModel):
-    """Class representing a single statement.
-
-    Each fact has a body and a list of sources.
-    If there are multiple facts make sure to break them apart
-    such that each one only uses a set of sources that are relevant to it.
-    """
-
-    fact: str = Field(..., description="Body of the sentence, as part of a response")
-    substring_quote: list[str] = Field(
-        ...,
-        description=(
-            "Each source should be a direct quote from the context, "
-            "as a substring of the original content"
-        ),
-    )
-
-    def _get_span(self, quote: str, context: str, errs: int = 100) -> Iterator[str]:
-        import regex
-
-        minor = quote
-        major = context
-
-        errs_ = 0
-        s = regex.search(f"({minor}){{e<={errs_}}}", major)
-        while s is None and errs_ <= errs:
-            errs_ += 1
-            s = regex.search(f"({minor}){{e<={errs_}}}", major)
-
-        if s is not None:
-            yield from s.spans()
-
-    def get_spans(self, context: str) -> Iterator[str]:
-        """Get spans of the substring quote in the context.
-
-        Args:
-            context: The context in which to find the spans of the substring quote.
-
-        Returns:
-            An iterator over the spans of the substring quote in the context.
-        """
-        for quote in self.substring_quote:
-            yield from self._get_span(quote, context)
-
-
-class QuestionAnswer(BaseModel):
-    """A question and its answer as a list of facts each one should have a source.
-    each sentence contains a body and a list of sources."""
-
-    question: str = Field(..., description="Question that was asked")
-    answer: list[FactWithEvidence] = Field(
-        ...,
-        description=(
-            "Body of the answer, each fact should be "
-            "its separate object with a body and a list of sources"
-        ),
-    )
-
-
-def create_citation_fuzzy_match_runnable(llm: BaseChatModel) -> Runnable:
-    """Create a citation fuzzy match Runnable.
-
-    Example usage:
-
-        .. code-block:: python
-
-            from langchain.chains import create_citation_fuzzy_match_runnable
-            from langchain_openai import ChatOpenAI
-
-            llm = ChatOpenAI(model="gpt-4o-mini")
-
-            context = "Alice has blue eyes. Bob has brown eyes. Charlie has green eyes."
-            question = "What color are Bob's eyes?"
-
-            chain = create_citation_fuzzy_match_runnable(llm)
-            chain.invoke({"question": question, "context": context})
-
-    Args:
-        llm: Language model to use for the chain. Must implement bind_tools.
-
-    Returns:
-        Runnable that can be used to answer questions with citations.
-
-    """
-    if llm.bind_tools is BaseChatModel.bind_tools:
-        msg = "Language model must implement bind_tools to use this function."
-        raise ValueError(msg)
-    prompt = ChatPromptTemplate(
-        [
-            SystemMessage(
-                "You are a world class algorithm to answer "
-                "questions with correct and exact citations.",
-            ),
-            HumanMessagePromptTemplate.from_template(
-                "Answer question using the following context."
-                "\n\n{context}"
-                "\n\nQuestion: {question}"
-                "\n\nTips: Make sure to cite your sources, "
-                "and use the exact words from the context.",
-            ),
-        ],
-    )
-    return prompt | llm.with_structured_output(QuestionAnswer)
-
-
-@deprecated(
-    since="0.2.13",
-    removal="1.0",
-    alternative="create_citation_fuzzy_match_runnable",
-)
-def create_citation_fuzzy_match_chain(llm: BaseLanguageModel) -> LLMChain:
-    """Create a citation fuzzy match chain.
-
-    Args:
-        llm: Language model to use for the chain.
-
-    Returns:
-        Chain (LLMChain) that can be used to answer questions with citations.
-    """
-    output_parser = PydanticOutputFunctionsParser(pydantic_schema=QuestionAnswer)
-    if hasattr(QuestionAnswer, "model_json_schema"):
-        schema = QuestionAnswer.model_json_schema()
-    else:
-        schema = QuestionAnswer.schema()
-    function = {
-        "name": schema["title"],
-        "description": schema["description"],
-        "parameters": schema,
-    }
-    llm_kwargs = get_llm_kwargs(function)
-    messages = [
-        SystemMessage(
-            content=(
-                "You are a world class algorithm to answer "
-                "questions with correct and exact citations."
-            ),
-        ),
-        HumanMessage(content="Answer question using the following context"),
-        HumanMessagePromptTemplate.from_template("{context}"),
-        HumanMessagePromptTemplate.from_template("Question: {question}"),
-        HumanMessage(
-            content=(
-                "Tips: Make sure to cite your sources, "
-                "and use the exact words from the context."
-            ),
-        ),
-    ]
-    prompt = ChatPromptTemplate(messages=messages)  # type: ignore[arg-type]
-
-    return LLMChain(
-        llm=llm,
-        prompt=prompt,
-        llm_kwargs=llm_kwargs,
-        output_parser=output_parser,
-    )

langchain/chains/openai_functions/extraction.py

@@ -1,197 +0,0 @@
-from typing import Any, Optional
-
-from langchain_core._api import deprecated
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers.openai_functions import (
-    JsonKeyOutputFunctionsParser,
-    PydanticAttrOutputFunctionsParser,
-)
-from langchain_core.prompts import BasePromptTemplate, ChatPromptTemplate
-from pydantic import BaseModel
-
-from langchain.chains.base import Chain
-from langchain.chains.llm import LLMChain
-from langchain.chains.openai_functions.utils import (
-    _convert_schema,
-    _resolve_schema_references,
-    get_llm_kwargs,
-)
-
-
-def _get_extraction_function(entity_schema: dict) -> dict:
-    return {
-        "name": "information_extraction",
-        "description": "Extracts the relevant information from the passage.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "info": {"type": "array", "items": _convert_schema(entity_schema)},
-            },
-            "required": ["info"],
-        },
-    }
-
-
-_EXTRACTION_TEMPLATE = """Extract and save the relevant entities mentioned \
-in the following passage together with their properties.
-
-Only extract the properties mentioned in the 'information_extraction' function.
-
-If a property is not present and is not required in the function parameters, do not include it in the output.
-
-Passage:
-{input}
-"""  # noqa: E501
-
-
-@deprecated(
-    since="0.1.14",
-    message=(
-        "LangChain has introduced a method called `with_structured_output` that"
-        "is available on ChatModels capable of tool calling."
-        "You can read more about the method here: "
-        "<https://python.langchain.com/docs/modules/model_io/chat/structured_output/>. "
-        "Please follow our extraction use case documentation for more guidelines"
-        "on how to do information extraction with LLMs."
-        "<https://python.langchain.com/docs/use_cases/extraction/>. "
-        "If you notice other issues, please provide "
-        "feedback here:"
-        "<https://github.com/langchain-ai/langchain/discussions/18154>"
-    ),
-    removal="1.0",
-    alternative=(
-        """
-            from pydantic import BaseModel, Field
-            from langchain_anthropic import ChatAnthropic
-
-            class Joke(BaseModel):
-                setup: str = Field(description="The setup of the joke")
-                punchline: str = Field(description="The punchline to the joke")
-
-            # Or any other chat model that supports tools.
-            # Please reference to to the documentation of structured_output
-            # to see an up to date list of which models support
-            # with_structured_output.
-            model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0)
-            structured_llm = model.with_structured_output(Joke)
-            structured_llm.invoke("Tell me a joke about cats.
-                Make sure to call the Joke function.")
-            """
-    ),
-)
-def create_extraction_chain(
-    schema: dict,
-    llm: BaseLanguageModel,
-    prompt: Optional[BasePromptTemplate] = None,
-    tags: Optional[list[str]] = None,
-    verbose: bool = False,  # noqa: FBT001,FBT002
-) -> Chain:
-    """Creates a chain that extracts information from a passage.
-
-    Args:
-        schema: The schema of the entities to extract.
-        llm: The language model to use.
-        prompt: The prompt to use for extraction.
-        verbose: Whether to run in verbose mode. In verbose mode, some intermediate
-            logs will be printed to the console. Defaults to the global `verbose` value,
-            accessible via `langchain.globals.get_verbose()`.
-
-    Returns:
-        Chain that can be used to extract information from a passage.
-    """
-    function = _get_extraction_function(schema)
-    extraction_prompt = prompt or ChatPromptTemplate.from_template(_EXTRACTION_TEMPLATE)
-    output_parser = JsonKeyOutputFunctionsParser(key_name="info")
-    llm_kwargs = get_llm_kwargs(function)
-    return LLMChain(
-        llm=llm,
-        prompt=extraction_prompt,
-        llm_kwargs=llm_kwargs,
-        output_parser=output_parser,
-        tags=tags,
-        verbose=verbose,
-    )
-
-
-@deprecated(
-    since="0.1.14",
-    message=(
-        "LangChain has introduced a method called `with_structured_output` that"
-        "is available on ChatModels capable of tool calling."
-        "You can read more about the method here: "
-        "<https://python.langchain.com/docs/modules/model_io/chat/structured_output/>. "
-        "Please follow our extraction use case documentation for more guidelines"
-        "on how to do information extraction with LLMs."
-        "<https://python.langchain.com/docs/use_cases/extraction/>. "
-        "If you notice other issues, please provide "
-        "feedback here:"
-        "<https://github.com/langchain-ai/langchain/discussions/18154>"
-    ),
-    removal="1.0",
-    alternative=(
-        """
-            from pydantic import BaseModel, Field
-            from langchain_anthropic import ChatAnthropic
-
-            class Joke(BaseModel):
-                setup: str = Field(description="The setup of the joke")
-                punchline: str = Field(description="The punchline to the joke")
-
-            # Or any other chat model that supports tools.
-            # Please reference to to the documentation of structured_output
-            # to see an up to date list of which models support
-            # with_structured_output.
-            model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0)
-            structured_llm = model.with_structured_output(Joke)
-            structured_llm.invoke("Tell me a joke about cats.
-                Make sure to call the Joke function.")
-            """
-    ),
-)
-def create_extraction_chain_pydantic(
-    pydantic_schema: Any,
-    llm: BaseLanguageModel,
-    prompt: Optional[BasePromptTemplate] = None,
-    verbose: bool = False,  # noqa: FBT001,FBT002
-) -> Chain:
-    """Creates a chain that extracts information from a passage using pydantic schema.
-
-    Args:
-        pydantic_schema: The pydantic schema of the entities to extract.
-        llm: The language model to use.
-        prompt: The prompt to use for extraction.
-        verbose: Whether to run in verbose mode. In verbose mode, some intermediate
-            logs will be printed to the console. Defaults to the global `verbose` value,
-            accessible via `langchain.globals.get_verbose()`
-
-    Returns:
-        Chain that can be used to extract information from a passage.
-    """
-
-    class PydanticSchema(BaseModel):
-        info: list[pydantic_schema]
-
-    if hasattr(pydantic_schema, "model_json_schema"):
-        openai_schema = pydantic_schema.model_json_schema()
-    else:
-        openai_schema = pydantic_schema.schema()
-
-    openai_schema = _resolve_schema_references(
-        openai_schema,
-        openai_schema.get("definitions", {}),
-    )
-
-    function = _get_extraction_function(openai_schema)
-    extraction_prompt = prompt or ChatPromptTemplate.from_template(_EXTRACTION_TEMPLATE)
-    output_parser = PydanticAttrOutputFunctionsParser(
-        pydantic_schema=PydanticSchema,
-        attr_name="info",
-    )
-    llm_kwargs = get_llm_kwargs(function)
-    return LLMChain(
-        llm=llm,
-        prompt=extraction_prompt,
-        llm_kwargs=llm_kwargs,
-        output_parser=output_parser,
-        verbose=verbose,
-    )