diff --git a/python/user_packages/Python313/site-packages/langchain_community/adapters/__init__.py b/python/user_packages/Python313/site-packages/langchain_community/adapters/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3834e1853e4a4f7255006f6ce6b1ea25a12b236c --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/adapters/__init__.py @@ -0,0 +1,8 @@ +"""**Adapters** are used to adapt LangChain models to other APIs. + +LangChain integrates with many model providers. +While LangChain has its own message and model APIs, +LangChain has also made it as easy as +possible to explore other models by exposing an **adapter** to adapt LangChain +models to the other APIs, as to the OpenAI API. +""" diff --git a/python/user_packages/Python313/site-packages/langchain_community/adapters/openai.py b/python/user_packages/Python313/site-packages/langchain_community/adapters/openai.py new file mode 100644 index 0000000000000000000000000000000000000000..09b0f5d1d51fa89e2c771b615b4aed546b8db1e0 --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/adapters/openai.py @@ -0,0 +1,421 @@ +from __future__ import annotations + +import importlib +from typing import ( + Any, + AsyncIterator, + Dict, + Iterable, + List, + Mapping, + Sequence, + Union, + overload, +) + +from langchain_core.chat_sessions import ChatSession +from langchain_core.messages import ( + AIMessage, + AIMessageChunk, + BaseMessage, + BaseMessageChunk, + ChatMessage, + FunctionMessage, + HumanMessage, + SystemMessage, + ToolMessage, +) +from pydantic import BaseModel +from typing_extensions import Literal + + +async def aenumerate( + iterable: AsyncIterator[Any], start: int = 0 +) -> AsyncIterator[tuple[int, Any]]: + """Async version of enumerate function.""" + i = start + async for x in iterable: + yield i, x + i += 1 + + +class IndexableBaseModel(BaseModel): + """Allows a BaseModel to return its fields by string variable indexing.""" + + def __getitem__(self, item: str) -> Any: + return getattr(self, item) + + +class Choice(IndexableBaseModel): + """Choice.""" + + message: dict + + +class ChatCompletions(IndexableBaseModel): + """Chat completions.""" + + choices: List[Choice] + + +class ChoiceChunk(IndexableBaseModel): + """Choice chunk.""" + + delta: dict + + +class ChatCompletionChunk(IndexableBaseModel): + """Chat completion chunk.""" + + choices: List[ChoiceChunk] + + +def convert_dict_to_message(_dict: Mapping[str, Any]) -> BaseMessage: + """Convert a dictionary to a LangChain message. + + Args: + _dict: The dictionary. + + Returns: + The LangChain message. + """ + role = _dict.get("role") + if role == "user": + return HumanMessage(content=_dict.get("content", "")) + elif role == "assistant": + # Fix for azure + # Also OpenAI returns None for tool invocations + content = _dict.get("content", "") or "" + additional_kwargs: Dict = {} + if function_call := _dict.get("function_call"): + additional_kwargs["function_call"] = dict(function_call) + if tool_calls := _dict.get("tool_calls"): + additional_kwargs["tool_calls"] = tool_calls + if context := _dict.get("context"): + additional_kwargs["context"] = context + return AIMessage(content=content, additional_kwargs=additional_kwargs) + elif role == "system": + return SystemMessage(content=_dict.get("content", "")) + elif role == "function": + return FunctionMessage(content=_dict.get("content", ""), name=_dict.get("name")) # type: ignore[arg-type] + elif role == "tool": + additional_kwargs = {} + if "name" in _dict: + additional_kwargs["name"] = _dict["name"] + return ToolMessage( + content=_dict.get("content", ""), + tool_call_id=_dict.get("tool_call_id"), + additional_kwargs=additional_kwargs, + ) + else: + return ChatMessage(content=_dict.get("content", ""), role=role) # type: ignore[arg-type] + + +def convert_message_to_dict(message: BaseMessage) -> dict: + """Convert a LangChain message to a dictionary. + + Args: + message: The LangChain message. + + Returns: + The dictionary. + """ + message_dict: Dict[str, Any] + if isinstance(message, ChatMessage): + message_dict = {"role": message.role, "content": message.content} + elif isinstance(message, HumanMessage): + message_dict = {"role": "user", "content": message.content} + elif isinstance(message, AIMessage): + message_dict = {"role": "assistant", "content": message.content} + if "function_call" in message.additional_kwargs: + message_dict["function_call"] = message.additional_kwargs["function_call"] + # If function call only, content is None not empty string + if message_dict["content"] == "": + message_dict["content"] = None + if "tool_calls" in message.additional_kwargs: + message_dict["tool_calls"] = message.additional_kwargs["tool_calls"] + # If tool calls only, content is None not empty string + if message_dict["content"] == "": + message_dict["content"] = None + if "context" in message.additional_kwargs: + message_dict["context"] = message.additional_kwargs["context"] + # If context only, content is None not empty string + if message_dict["content"] == "": + message_dict["content"] = None + elif isinstance(message, SystemMessage): + message_dict = {"role": "system", "content": message.content} + elif isinstance(message, FunctionMessage): + message_dict = { + "role": "function", + "content": message.content, + "name": message.name, + } + elif isinstance(message, ToolMessage): + message_dict = { + "role": "tool", + "content": message.content, + "tool_call_id": message.tool_call_id, + } + else: + raise TypeError(f"Got unknown type {message}") + if "name" in message.additional_kwargs: + message_dict["name"] = message.additional_kwargs["name"] + return message_dict + + +def convert_openai_messages(messages: Sequence[Dict[str, Any]]) -> List[BaseMessage]: + """Convert dictionaries representing OpenAI messages to LangChain format. + + Args: + messages: List of dictionaries representing OpenAI messages + + Returns: + List of LangChain BaseMessage objects. + """ + return [convert_dict_to_message(m) for m in messages] + + +def _convert_message_chunk(chunk: BaseMessageChunk, i: int) -> dict: + _dict: Dict[str, Any] = {} + if isinstance(chunk, AIMessageChunk): + if i == 0: + # Only shows up in the first chunk + _dict["role"] = "assistant" + if "function_call" in chunk.additional_kwargs: + _dict["function_call"] = chunk.additional_kwargs["function_call"] + # If the first chunk is a function call, the content is not empty string, + # not missing, but None. + if i == 0: + _dict["content"] = None + if "tool_calls" in chunk.additional_kwargs: + _dict["tool_calls"] = chunk.additional_kwargs["tool_calls"] + # If the first chunk is tool calls, the content is not empty string, + # not missing, but None. + if i == 0: + _dict["content"] = None + else: + _dict["content"] = chunk.content + else: + raise ValueError(f"Got unexpected streaming chunk type: {type(chunk)}") + # This only happens at the end of streams, and OpenAI returns as empty dict + if _dict == {"content": ""}: + _dict = {} + return _dict + + +def _convert_message_chunk_to_delta(chunk: BaseMessageChunk, i: int) -> Dict[str, Any]: + _dict = _convert_message_chunk(chunk, i) + return {"choices": [{"delta": _dict}]} + + +class ChatCompletion: + """Chat completion.""" + + @overload + @staticmethod + def create( + messages: Sequence[Dict[str, Any]], + *, + provider: str = "ChatOpenAI", + stream: Literal[False] = False, + **kwargs: Any, + ) -> dict: ... + + @overload + @staticmethod + def create( + messages: Sequence[Dict[str, Any]], + *, + provider: str = "ChatOpenAI", + stream: Literal[True], + **kwargs: Any, + ) -> Iterable: ... + + @staticmethod + def create( + messages: Sequence[Dict[str, Any]], + *, + provider: str = "ChatOpenAI", + stream: bool = False, + **kwargs: Any, + ) -> Union[dict, Iterable]: + models = importlib.import_module("langchain.chat_models") + model_cls = getattr(models, provider) + model_config = model_cls(**kwargs) + converted_messages = convert_openai_messages(messages) + if not stream: + result = model_config.invoke(converted_messages) + return {"choices": [{"message": convert_message_to_dict(result)}]} + else: + return ( + _convert_message_chunk_to_delta(c, i) + for i, c in enumerate(model_config.stream(converted_messages)) + ) + + @overload + @staticmethod + async def acreate( + messages: Sequence[Dict[str, Any]], + *, + provider: str = "ChatOpenAI", + stream: Literal[False] = False, + **kwargs: Any, + ) -> dict: ... + + @overload + @staticmethod + async def acreate( + messages: Sequence[Dict[str, Any]], + *, + provider: str = "ChatOpenAI", + stream: Literal[True], + **kwargs: Any, + ) -> AsyncIterator: ... + + @staticmethod + async def acreate( + messages: Sequence[Dict[str, Any]], + *, + provider: str = "ChatOpenAI", + stream: bool = False, + **kwargs: Any, + ) -> Union[dict, AsyncIterator]: + models = importlib.import_module("langchain.chat_models") + model_cls = getattr(models, provider) + model_config = model_cls(**kwargs) + converted_messages = convert_openai_messages(messages) + if not stream: + result = await model_config.ainvoke(converted_messages) + return {"choices": [{"message": convert_message_to_dict(result)}]} + else: + return ( + _convert_message_chunk_to_delta(c, i) + async for i, c in aenumerate(model_config.astream(converted_messages)) + ) + + +def _has_assistant_message(session: ChatSession) -> bool: + """Check if chat session has an assistant message.""" + return any([isinstance(m, AIMessage) for m in session["messages"]]) + + +def convert_messages_for_finetuning( + sessions: Iterable[ChatSession], +) -> List[List[dict]]: + """Convert messages to a list of lists of dictionaries for fine-tuning. + + Args: + sessions: The chat sessions. + + Returns: + The list of lists of dictionaries. + """ + return [ + [convert_message_to_dict(s) for s in session["messages"]] + for session in sessions + if _has_assistant_message(session) + ] + + +class Completions: + """Completions.""" + + @overload + @staticmethod + def create( + messages: Sequence[Dict[str, Any]], + *, + provider: str = "ChatOpenAI", + stream: Literal[False] = False, + **kwargs: Any, + ) -> ChatCompletions: ... + + @overload + @staticmethod + def create( + messages: Sequence[Dict[str, Any]], + *, + provider: str = "ChatOpenAI", + stream: Literal[True], + **kwargs: Any, + ) -> Iterable: ... + + @staticmethod + def create( + messages: Sequence[Dict[str, Any]], + *, + provider: str = "ChatOpenAI", + stream: bool = False, + **kwargs: Any, + ) -> Union[ChatCompletions, Iterable]: + models = importlib.import_module("langchain.chat_models") + model_cls = getattr(models, provider) + model_config = model_cls(**kwargs) + converted_messages = convert_openai_messages(messages) + if not stream: + result = model_config.invoke(converted_messages) + return ChatCompletions( + choices=[Choice(message=convert_message_to_dict(result))] + ) + else: + return ( + ChatCompletionChunk( + choices=[ChoiceChunk(delta=_convert_message_chunk(c, i))] + ) + for i, c in enumerate(model_config.stream(converted_messages)) + ) + + @overload + @staticmethod + async def acreate( + messages: Sequence[Dict[str, Any]], + *, + provider: str = "ChatOpenAI", + stream: Literal[False] = False, + **kwargs: Any, + ) -> ChatCompletions: ... + + @overload + @staticmethod + async def acreate( + messages: Sequence[Dict[str, Any]], + *, + provider: str = "ChatOpenAI", + stream: Literal[True], + **kwargs: Any, + ) -> AsyncIterator: ... + + @staticmethod + async def acreate( + messages: Sequence[Dict[str, Any]], + *, + provider: str = "ChatOpenAI", + stream: bool = False, + **kwargs: Any, + ) -> Union[ChatCompletions, AsyncIterator]: + models = importlib.import_module("langchain.chat_models") + model_cls = getattr(models, provider) + model_config = model_cls(**kwargs) + converted_messages = convert_openai_messages(messages) + if not stream: + result = await model_config.ainvoke(converted_messages) + return ChatCompletions( + choices=[Choice(message=convert_message_to_dict(result))] + ) + else: + return ( + ChatCompletionChunk( + choices=[ChoiceChunk(delta=_convert_message_chunk(c, i))] + ) + async for i, c in aenumerate(model_config.astream(converted_messages)) + ) + + +class Chat: + """Chat.""" + + def __init__(self) -> None: + self.completions = Completions() + + +chat = Chat() diff --git a/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/__init__.py b/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e0e67479ffd89d101972ce80f73516fef2c0a73d --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/__init__.py @@ -0,0 +1,170 @@ +"""**Toolkits** are sets of tools that can be used to interact with +various services and APIs. +""" + +import importlib +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from langchain_community.agent_toolkits.ainetwork.toolkit import ( + AINetworkToolkit, + ) + from langchain_community.agent_toolkits.amadeus.toolkit import ( + AmadeusToolkit, + ) + from langchain_community.agent_toolkits.azure_ai_services import ( + AzureAiServicesToolkit, + ) + from langchain_community.agent_toolkits.azure_cognitive_services import ( + AzureCognitiveServicesToolkit, + ) + from langchain_community.agent_toolkits.cassandra_database.toolkit import ( + CassandraDatabaseToolkit, # noqa: F401 + ) + from langchain_community.agent_toolkits.cogniswitch.toolkit import ( + CogniswitchToolkit, + ) + from langchain_community.agent_toolkits.connery import ( + ConneryToolkit, + ) + from langchain_community.agent_toolkits.file_management.toolkit import ( + FileManagementToolkit, + ) + from langchain_community.agent_toolkits.gmail.toolkit import ( + GmailToolkit, + ) + from langchain_community.agent_toolkits.jira.toolkit import ( + JiraToolkit, + ) + from langchain_community.agent_toolkits.json.base import ( + create_json_agent, + ) + from langchain_community.agent_toolkits.json.toolkit import ( + JsonToolkit, + ) + from langchain_community.agent_toolkits.multion.toolkit import ( + MultionToolkit, + ) + from langchain_community.agent_toolkits.nasa.toolkit import ( + NasaToolkit, + ) + from langchain_community.agent_toolkits.nla.toolkit import ( + NLAToolkit, + ) + from langchain_community.agent_toolkits.office365.toolkit import ( + O365Toolkit, + ) + from langchain_community.agent_toolkits.openapi.base import ( + create_openapi_agent, + ) + from langchain_community.agent_toolkits.openapi.toolkit import ( + OpenAPIToolkit, + ) + from langchain_community.agent_toolkits.playwright.toolkit import ( + PlayWrightBrowserToolkit, + ) + from langchain_community.agent_toolkits.polygon.toolkit import ( + PolygonToolkit, + ) + from langchain_community.agent_toolkits.powerbi.base import ( + create_pbi_agent, + ) + from langchain_community.agent_toolkits.powerbi.chat_base import ( + create_pbi_chat_agent, + ) + from langchain_community.agent_toolkits.powerbi.toolkit import ( + PowerBIToolkit, + ) + from langchain_community.agent_toolkits.slack.toolkit import ( + SlackToolkit, + ) + from langchain_community.agent_toolkits.spark_sql.base import ( + create_spark_sql_agent, + ) + from langchain_community.agent_toolkits.spark_sql.toolkit import ( + SparkSQLToolkit, + ) + from langchain_community.agent_toolkits.sql.base import ( + create_sql_agent, + ) + from langchain_community.agent_toolkits.sql.toolkit import ( + SQLDatabaseToolkit, + ) + from langchain_community.agent_toolkits.steam.toolkit import ( + SteamToolkit, + ) + from langchain_community.agent_toolkits.zapier.toolkit import ( + ZapierToolkit, + ) + +__all__ = [ + "AINetworkToolkit", + "AmadeusToolkit", + "AzureAiServicesToolkit", + "AzureCognitiveServicesToolkit", + "CogniswitchToolkit", + "ConneryToolkit", + "FileManagementToolkit", + "GmailToolkit", + "JiraToolkit", + "JsonToolkit", + "MultionToolkit", + "NLAToolkit", + "NasaToolkit", + "O365Toolkit", + "OpenAPIToolkit", + "PlayWrightBrowserToolkit", + "PolygonToolkit", + "PowerBIToolkit", + "SQLDatabaseToolkit", + "SlackToolkit", + "SparkSQLToolkit", + "SteamToolkit", + "ZapierToolkit", + "create_json_agent", + "create_openapi_agent", + "create_pbi_agent", + "create_pbi_chat_agent", + "create_spark_sql_agent", + "create_sql_agent", +] + + +_module_lookup = { + "AINetworkToolkit": "langchain_community.agent_toolkits.ainetwork.toolkit", + "AmadeusToolkit": "langchain_community.agent_toolkits.amadeus.toolkit", + "AzureAiServicesToolkit": "langchain_community.agent_toolkits.azure_ai_services", + "AzureCognitiveServicesToolkit": "langchain_community.agent_toolkits.azure_cognitive_services", # noqa: E501 + "CogniswitchToolkit": "langchain_community.agent_toolkits.cogniswitch.toolkit", + "ConneryToolkit": "langchain_community.agent_toolkits.connery", + "FileManagementToolkit": "langchain_community.agent_toolkits.file_management.toolkit", # noqa: E501 + "GmailToolkit": "langchain_community.agent_toolkits.gmail.toolkit", + "JiraToolkit": "langchain_community.agent_toolkits.jira.toolkit", + "JsonToolkit": "langchain_community.agent_toolkits.json.toolkit", + "MultionToolkit": "langchain_community.agent_toolkits.multion.toolkit", + "NLAToolkit": "langchain_community.agent_toolkits.nla.toolkit", + "NasaToolkit": "langchain_community.agent_toolkits.nasa.toolkit", + "O365Toolkit": "langchain_community.agent_toolkits.office365.toolkit", + "OpenAPIToolkit": "langchain_community.agent_toolkits.openapi.toolkit", + "PlayWrightBrowserToolkit": "langchain_community.agent_toolkits.playwright.toolkit", + "PolygonToolkit": "langchain_community.agent_toolkits.polygon.toolkit", + "PowerBIToolkit": "langchain_community.agent_toolkits.powerbi.toolkit", + "SQLDatabaseToolkit": "langchain_community.agent_toolkits.sql.toolkit", + "SlackToolkit": "langchain_community.agent_toolkits.slack.toolkit", + "SparkSQLToolkit": "langchain_community.agent_toolkits.spark_sql.toolkit", + "SteamToolkit": "langchain_community.agent_toolkits.steam.toolkit", + "ZapierToolkit": "langchain_community.agent_toolkits.zapier.toolkit", + "create_json_agent": "langchain_community.agent_toolkits.json.base", + "create_openapi_agent": "langchain_community.agent_toolkits.openapi.base", + "create_pbi_agent": "langchain_community.agent_toolkits.powerbi.base", + "create_pbi_chat_agent": "langchain_community.agent_toolkits.powerbi.chat_base", + "create_spark_sql_agent": "langchain_community.agent_toolkits.spark_sql.base", + "create_sql_agent": "langchain_community.agent_toolkits.sql.base", +} + + +def __getattr__(name: str) -> Any: + if name in _module_lookup: + module = importlib.import_module(_module_lookup[name]) + return getattr(module, name) + raise AttributeError(f"module {__name__} has no attribute {name}") diff --git a/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/azure_ai_services.py b/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/azure_ai_services.py new file mode 100644 index 0000000000000000000000000000000000000000..1a69fa7c5bd315f00e2c7e56e1e262979a3ede2b --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/azure_ai_services.py @@ -0,0 +1,31 @@ +from __future__ import annotations + +from typing import List + +from langchain_core.tools import BaseTool +from langchain_core.tools.base import BaseToolkit + +from langchain_community.tools.azure_ai_services import ( + AzureAiServicesDocumentIntelligenceTool, + AzureAiServicesImageAnalysisTool, + AzureAiServicesSpeechToTextTool, + AzureAiServicesTextAnalyticsForHealthTool, + AzureAiServicesTextToSpeechTool, +) + + +class AzureAiServicesToolkit(BaseToolkit): + """Toolkit for Azure AI Services.""" + + def get_tools(self) -> List[BaseTool]: + """Get the tools in the toolkit.""" + + tools: List[BaseTool] = [ + AzureAiServicesDocumentIntelligenceTool(), # type: ignore[call-arg] + AzureAiServicesImageAnalysisTool(), + AzureAiServicesSpeechToTextTool(), # type: ignore[call-arg] + AzureAiServicesTextToSpeechTool(), # type: ignore[call-arg] + AzureAiServicesTextAnalyticsForHealthTool(), # type: ignore[call-arg] + ] + + return tools diff --git a/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/azure_cognitive_services.py b/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/azure_cognitive_services.py new file mode 100644 index 0000000000000000000000000000000000000000..1f9b27bf481453d8a524be2ef48b9924ec8ae1ce --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/azure_cognitive_services.py @@ -0,0 +1,34 @@ +from __future__ import annotations + +import sys +from typing import List + +from langchain_core.tools import BaseTool +from langchain_core.tools.base import BaseToolkit + +from langchain_community.tools.azure_cognitive_services import ( + AzureCogsFormRecognizerTool, + AzureCogsImageAnalysisTool, + AzureCogsSpeech2TextTool, + AzureCogsText2SpeechTool, + AzureCogsTextAnalyticsHealthTool, +) + + +class AzureCognitiveServicesToolkit(BaseToolkit): + """Toolkit for Azure Cognitive Services.""" + + def get_tools(self) -> List[BaseTool]: + """Get the tools in the toolkit.""" + + tools: List[BaseTool] = [ + AzureCogsFormRecognizerTool(), # type: ignore[call-arg] + AzureCogsSpeech2TextTool(), # type: ignore[call-arg] + AzureCogsText2SpeechTool(), # type: ignore[call-arg] + AzureCogsTextAnalyticsHealthTool(), # type: ignore[call-arg] + ] + + # TODO: Remove check once azure-ai-vision supports MacOS. + if sys.platform.startswith("linux") or sys.platform.startswith("win"): + tools.append(AzureCogsImageAnalysisTool()) # type: ignore[call-arg] + return tools diff --git a/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/base.py b/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/base.py new file mode 100644 index 0000000000000000000000000000000000000000..6a2ad9cdb9738050ae163951bb9e15bd76566da5 --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/base.py @@ -0,0 +1,5 @@ +"""Toolkits for agents.""" + +from langchain_core.tools.base import BaseToolkit + +__all__ = ["BaseToolkit"] diff --git a/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/load_tools.py b/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/load_tools.py new file mode 100644 index 0000000000000000000000000000000000000000..510ee7fe69796ef19f94ed798b3e5330afca756f --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/agent_toolkits/load_tools.py @@ -0,0 +1,771 @@ +# flake8: noqa +"""Tools provide access to various resources and services. + +LangChain has a large ecosystem of integrations with various external resources +like local and remote file systems, APIs and databases. + +These integrations allow developers to create versatile applications that combine the +power of LLMs with the ability to access, interact with and manipulate external +resources. + +When developing an application, developers should inspect the capabilities and +permissions of the tools that underlie the given agent toolkit, and determine +whether permissions of the given toolkit are appropriate for the application. + +See [Security](https://python.langchain.com/docs/security) for more information. +""" + +import warnings +from typing import Any, Dict, List, Optional, Callable, Tuple + +from mypy_extensions import Arg, KwArg + +from langchain_community.tools.arxiv.tool import ArxivQueryRun +from langchain_community.tools.bing_search.tool import BingSearchRun +from langchain_community.tools.dataforseo_api_search import DataForSeoAPISearchResults +from langchain_community.tools.dataforseo_api_search import DataForSeoAPISearchRun +from langchain_community.tools.ddg_search.tool import DuckDuckGoSearchRun +from langchain_community.tools.eleven_labs.text2speech import ElevenLabsText2SpeechTool +from langchain_community.tools.file_management import ReadFileTool +from langchain_community.tools.golden_query.tool import GoldenQueryRun +from langchain_community.tools.google_cloud.texttospeech import ( + GoogleCloudTextToSpeechTool, +) +from langchain_community.tools.google_finance.tool import GoogleFinanceQueryRun +from langchain_community.tools.google_jobs.tool import GoogleJobsQueryRun +from langchain_community.tools.google_lens.tool import GoogleLensQueryRun +from langchain_community.tools.google_scholar.tool import GoogleScholarQueryRun +from langchain_community.tools.google_search.tool import ( + GoogleSearchResults, + GoogleSearchRun, +) +from langchain_community.tools.google_serper.tool import ( + GoogleSerperResults, + GoogleSerperRun, +) +from langchain_community.tools.google_trends.tool import GoogleTrendsQueryRun +from langchain_community.tools.graphql.tool import BaseGraphQLTool +from langchain_community.tools.human.tool import HumanInputRun +from langchain_community.tools.memorize.tool import Memorize +from langchain_community.tools.merriam_webster.tool import MerriamWebsterQueryRun +from langchain_community.tools.metaphor_search.tool import MetaphorSearchResults +from langchain_community.tools.openweathermap.tool import OpenWeatherMapQueryRun +from langchain_community.tools.pubmed.tool import PubmedQueryRun +from langchain_community.tools.reddit_search.tool import RedditSearchRun +from langchain_community.tools.requests.tool import ( + RequestsDeleteTool, + RequestsGetTool, + RequestsPatchTool, + RequestsPostTool, + RequestsPutTool, +) +from langchain_community.tools.scenexplain.tool import SceneXplainTool +from langchain_community.tools.searchapi.tool import SearchAPIResults, SearchAPIRun +from langchain_community.tools.searx_search.tool import ( + SearxSearchResults, + SearxSearchRun, +) +from langchain_community.tools.shell.tool import ShellTool +from langchain_community.tools.sleep.tool import SleepTool +from langchain_community.tools.stackexchange.tool import StackExchangeTool +from langchain_community.tools.wikipedia.tool import WikipediaQueryRun +from langchain_community.tools.wolfram_alpha.tool import WolframAlphaQueryRun +from langchain_community.utilities.arxiv import ArxivAPIWrapper +from langchain_community.utilities.awslambda import LambdaWrapper +from langchain_community.utilities.bing_search import BingSearchAPIWrapper +from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper +from langchain_community.utilities.dataforseo_api_search import DataForSeoAPIWrapper +from langchain_community.utilities.duckduckgo_search import DuckDuckGoSearchAPIWrapper +from langchain_community.utilities.golden_query import GoldenQueryAPIWrapper +from langchain_community.utilities.google_books import GoogleBooksAPIWrapper +from langchain_community.utilities.google_finance import GoogleFinanceAPIWrapper +from langchain_community.utilities.google_jobs import GoogleJobsAPIWrapper +from langchain_community.utilities.google_lens import GoogleLensAPIWrapper +from langchain_community.utilities.google_scholar import GoogleScholarAPIWrapper +from langchain_community.utilities.google_search import GoogleSearchAPIWrapper +from langchain_community.utilities.google_serper import GoogleSerperAPIWrapper +from langchain_community.utilities.google_trends import GoogleTrendsAPIWrapper +from langchain_community.utilities.graphql import GraphQLAPIWrapper +from langchain_community.utilities.merriam_webster import MerriamWebsterAPIWrapper +from langchain_community.utilities.metaphor_search import MetaphorSearchAPIWrapper +from langchain_community.utilities.openweathermap import OpenWeatherMapAPIWrapper +from langchain_community.utilities.pubmed import PubMedAPIWrapper +from langchain_community.utilities.reddit_search import RedditSearchAPIWrapper +from langchain_community.utilities.requests import TextRequestsWrapper +from langchain_community.utilities.searchapi import SearchApiAPIWrapper +from langchain_community.utilities.searx_search import SearxSearchWrapper +from langchain_community.utilities.serpapi import SerpAPIWrapper +from langchain_community.utilities.stackexchange import StackExchangeAPIWrapper +from langchain_community.utilities.twilio import TwilioAPIWrapper +from langchain_community.utilities.wikipedia import WikipediaAPIWrapper +from langchain_community.utilities.wolfram_alpha import WolframAlphaAPIWrapper +from langchain_core.callbacks import BaseCallbackManager +from langchain_core.callbacks import Callbacks +from langchain_core.language_models import BaseLanguageModel +from langchain_core.tools import BaseTool, Tool + + +def _get_tools_requests_get() -> BaseTool: + # Dangerous requests are allowed here, because there's another flag that the user + # has to provide in order to actually opt in. + # This is a private function and should not be used directly. + return RequestsGetTool( + requests_wrapper=TextRequestsWrapper(), allow_dangerous_requests=True + ) + + +def _get_tools_requests_post() -> BaseTool: + # Dangerous requests are allowed here, because there's another flag that the user + # has to provide in order to actually opt in. + # This is a private function and should not be used directly. + return RequestsPostTool( + requests_wrapper=TextRequestsWrapper(), allow_dangerous_requests=True + ) + + +def _get_tools_requests_patch() -> BaseTool: + # Dangerous requests are allowed here, because there's another flag that the user + # has to provide in order to actually opt in. + # This is a private function and should not be used directly. + return RequestsPatchTool( + requests_wrapper=TextRequestsWrapper(), allow_dangerous_requests=True + ) + + +def _get_tools_requests_put() -> BaseTool: + # Dangerous requests are allowed here, because there's another flag that the user + # has to provide in order to actually opt in. + # This is a private function and should not be used directly. + return RequestsPutTool( + requests_wrapper=TextRequestsWrapper(), allow_dangerous_requests=True + ) + + +def _get_tools_requests_delete() -> BaseTool: + # Dangerous requests are allowed here, because there's another flag that the user + # has to provide in order to actually opt in. + # This is a private function and should not be used directly. + return RequestsDeleteTool( + requests_wrapper=TextRequestsWrapper(), allow_dangerous_requests=True + ) + + +def _get_terminal() -> BaseTool: + return ShellTool() + + +def _get_sleep() -> BaseTool: + return SleepTool() + + +_BASE_TOOLS: Dict[str, Callable[[], BaseTool]] = { + "sleep": _get_sleep, +} + +DANGEROUS_TOOLS = { + # Tools that contain some level of risk. + # Please use with caution and read the documentation of these tools + # to understand the risks and how to mitigate them. + # Refer to https://python.langchain.com/docs/security + # for more information. + "requests": _get_tools_requests_get, # preserved for backwards compatibility + "requests_get": _get_tools_requests_get, + "requests_post": _get_tools_requests_post, + "requests_patch": _get_tools_requests_patch, + "requests_put": _get_tools_requests_put, + "requests_delete": _get_tools_requests_delete, + "terminal": _get_terminal, +} + + +def _get_llm_math(llm: BaseLanguageModel) -> BaseTool: + try: + from langchain_classic.chains.llm_math.base import LLMMathChain + except ImportError: + raise ImportError( + "LLM Math tools require the library `langchain` to be installed." + " Please install it with `pip install langchain`." + ) + return Tool( + name="Calculator", + description="Useful for when you need to answer questions about math.", + func=LLMMathChain.from_llm(llm=llm).run, + coroutine=LLMMathChain.from_llm(llm=llm).arun, + ) + + +def _get_open_meteo_api(llm: BaseLanguageModel) -> BaseTool: + try: + from langchain_classic.chains.api.base import APIChain + from langchain_classic.chains.api import ( + open_meteo_docs, + ) + except ImportError: + raise ImportError( + "API tools require the library `langchain` to be installed." + " Please install it with `pip install langchain`." + ) + chain = APIChain.from_llm_and_api_docs( + llm, + open_meteo_docs.OPEN_METEO_DOCS, + limit_to_domains=["https://api.open-meteo.com/"], + ) + return Tool( + name="Open-Meteo-API", + description="Useful for when you want to get weather information from the OpenMeteo API. The input should be a question in natural language that this API can answer.", + func=chain.run, + ) + + +_LLM_TOOLS: Dict[str, Callable[[BaseLanguageModel], BaseTool]] = { + "llm-math": _get_llm_math, + "open-meteo-api": _get_open_meteo_api, +} + + +def _get_news_api(llm: BaseLanguageModel, **kwargs: Any) -> BaseTool: + news_api_key = kwargs["news_api_key"] + try: + from langchain_classic.chains.api.base import APIChain + from langchain_classic.chains.api import ( + news_docs, + ) + except ImportError: + raise ImportError( + "API tools require the library `langchain` to be installed." + " Please install it with `pip install langchain`." + ) + chain = APIChain.from_llm_and_api_docs( + llm, + news_docs.NEWS_DOCS, + headers={"X-Api-Key": news_api_key}, + limit_to_domains=["https://newsapi.org/"], + ) + return Tool( + name="News-API", + description="Use this when you want to get information about the top headlines of current news stories. The input should be a question in natural language that this API can answer.", + func=chain.run, + ) + + +def _get_tmdb_api(llm: BaseLanguageModel, **kwargs: Any) -> BaseTool: + tmdb_bearer_token = kwargs["tmdb_bearer_token"] + try: + from langchain_classic.chains.api.base import APIChain + from langchain_classic.chains.api import ( + tmdb_docs, + ) + except ImportError: + raise ImportError( + "API tools require the library `langchain` to be installed." + " Please install it with `pip install langchain`." + ) + chain = APIChain.from_llm_and_api_docs( + llm, + tmdb_docs.TMDB_DOCS, + headers={"Authorization": f"Bearer {tmdb_bearer_token}"}, + limit_to_domains=["https://api.themoviedb.org/"], + ) + return Tool( + name="TMDB-API", + description="Useful for when you want to get information from The Movie Database. The input should be a question in natural language that this API can answer.", + func=chain.run, + ) + + +def _get_podcast_api(llm: BaseLanguageModel, **kwargs: Any) -> BaseTool: + listen_api_key = kwargs["listen_api_key"] + try: + from langchain_classic.chains.api.base import APIChain + from langchain_classic.chains.api import ( + podcast_docs, + ) + except ImportError: + raise ImportError( + "API tools require the library `langchain` to be installed." + " Please install it with `pip install langchain`." + ) + chain = APIChain.from_llm_and_api_docs( + llm, + podcast_docs.PODCAST_DOCS, + headers={"X-ListenAPI-Key": listen_api_key}, + limit_to_domains=["https://listen-api.listennotes.com/"], + ) + return Tool( + name="Podcast-API", + description="Use the Listen Notes Podcast API to search all podcasts or episodes. The input should be a question in natural language that this API can answer.", + func=chain.run, + ) + + +def _get_lambda_api(**kwargs: Any) -> BaseTool: + return Tool( + name=kwargs["awslambda_tool_name"], + description=kwargs["awslambda_tool_description"], + func=LambdaWrapper(**kwargs).run, + ) + + +def _get_wolfram_alpha(**kwargs: Any) -> BaseTool: + return WolframAlphaQueryRun(api_wrapper=WolframAlphaAPIWrapper(**kwargs)) + + +def _get_google_search(**kwargs: Any) -> BaseTool: + return GoogleSearchRun(api_wrapper=GoogleSearchAPIWrapper(**kwargs)) + + +def _get_merriam_webster(**kwargs: Any) -> BaseTool: + return MerriamWebsterQueryRun(api_wrapper=MerriamWebsterAPIWrapper(**kwargs)) + + +def _get_wikipedia(**kwargs: Any) -> BaseTool: + return WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper(**kwargs)) + + +def _get_arxiv(**kwargs: Any) -> BaseTool: + return ArxivQueryRun(api_wrapper=ArxivAPIWrapper(**kwargs)) + + +def _get_golden_query(**kwargs: Any) -> BaseTool: + return GoldenQueryRun(api_wrapper=GoldenQueryAPIWrapper(**kwargs)) + + +def _get_pubmed(**kwargs: Any) -> BaseTool: + return PubmedQueryRun(api_wrapper=PubMedAPIWrapper(**kwargs)) + + +def _get_google_books(**kwargs: Any) -> BaseTool: + from langchain_community.tools.google_books import GoogleBooksQueryRun + + return GoogleBooksQueryRun(api_wrapper=GoogleBooksAPIWrapper(**kwargs)) + + +def _get_google_jobs(**kwargs: Any) -> BaseTool: + return GoogleJobsQueryRun(api_wrapper=GoogleJobsAPIWrapper(**kwargs)) + + +def _get_google_lens(**kwargs: Any) -> BaseTool: + return GoogleLensQueryRun(api_wrapper=GoogleLensAPIWrapper(**kwargs)) + + +def _get_google_serper(**kwargs: Any) -> BaseTool: + return GoogleSerperRun(api_wrapper=GoogleSerperAPIWrapper(**kwargs)) + + +def _get_google_scholar(**kwargs: Any) -> BaseTool: + return GoogleScholarQueryRun(api_wrapper=GoogleScholarAPIWrapper(**kwargs)) + + +def _get_google_finance(**kwargs: Any) -> BaseTool: + return GoogleFinanceQueryRun(api_wrapper=GoogleFinanceAPIWrapper(**kwargs)) + + +def _get_google_trends(**kwargs: Any) -> BaseTool: + return GoogleTrendsQueryRun(api_wrapper=GoogleTrendsAPIWrapper(**kwargs)) + + +def _get_google_serper_results_json(**kwargs: Any) -> BaseTool: + return GoogleSerperResults(api_wrapper=GoogleSerperAPIWrapper(**kwargs)) + + +def _get_google_search_results_json(**kwargs: Any) -> BaseTool: + return GoogleSearchResults(api_wrapper=GoogleSearchAPIWrapper(**kwargs)) + + +def _get_searchapi(**kwargs: Any) -> BaseTool: + return SearchAPIRun(api_wrapper=SearchApiAPIWrapper(**kwargs)) + + +def _get_searchapi_results_json(**kwargs: Any) -> BaseTool: + return SearchAPIResults(api_wrapper=SearchApiAPIWrapper(**kwargs)) + + +def _get_serpapi(**kwargs: Any) -> BaseTool: + return Tool( + name="Search", + description="A search engine. Useful for when you need to answer questions about current events. Input should be a search query.", + func=SerpAPIWrapper(**kwargs).run, + coroutine=SerpAPIWrapper(**kwargs).arun, + ) + + +def _get_stackexchange(**kwargs: Any) -> BaseTool: + return StackExchangeTool(api_wrapper=StackExchangeAPIWrapper(**kwargs)) + + +def _get_dalle_image_generator(**kwargs: Any) -> Tool: + return Tool( + "Dall-E-Image-Generator", + DallEAPIWrapper(**kwargs).run, + "A wrapper around OpenAI DALL-E API. Useful for when you need to generate images from a text description. Input should be an image description.", + ) + + +def _get_twilio(**kwargs: Any) -> BaseTool: + return Tool( + name="Text-Message", + description="Useful for when you need to send a text message to a provided phone number.", + func=TwilioAPIWrapper(**kwargs).run, + ) + + +def _get_searx_search(**kwargs: Any) -> BaseTool: + return SearxSearchRun(wrapper=SearxSearchWrapper(**kwargs)) + + +def _get_searx_search_results_json(**kwargs: Any) -> BaseTool: + wrapper_kwargs = {k: v for k, v in kwargs.items() if k != "num_results"} + return SearxSearchResults(wrapper=SearxSearchWrapper(**wrapper_kwargs), **kwargs) + + +def _get_bing_search(**kwargs: Any) -> BaseTool: + return BingSearchRun(api_wrapper=BingSearchAPIWrapper(**kwargs)) + + +def _get_metaphor_search(**kwargs: Any) -> BaseTool: + return MetaphorSearchResults(api_wrapper=MetaphorSearchAPIWrapper(**kwargs)) + + +def _get_ddg_search(**kwargs: Any) -> BaseTool: + return DuckDuckGoSearchRun(api_wrapper=DuckDuckGoSearchAPIWrapper(**kwargs)) + + +def _get_human_tool(**kwargs: Any) -> BaseTool: + return HumanInputRun(**kwargs) + + +def _get_scenexplain(**kwargs: Any) -> BaseTool: + return SceneXplainTool(**kwargs) + + +def _get_graphql_tool(**kwargs: Any) -> BaseTool: + return BaseGraphQLTool(graphql_wrapper=GraphQLAPIWrapper(**kwargs)) + + +def _get_openweathermap(**kwargs: Any) -> BaseTool: + return OpenWeatherMapQueryRun(api_wrapper=OpenWeatherMapAPIWrapper(**kwargs)) + + +def _get_dataforseo_api_search(**kwargs: Any) -> BaseTool: + return DataForSeoAPISearchRun(api_wrapper=DataForSeoAPIWrapper(**kwargs)) + + +def _get_dataforseo_api_search_json(**kwargs: Any) -> BaseTool: + return DataForSeoAPISearchResults(api_wrapper=DataForSeoAPIWrapper(**kwargs)) + + +def _get_eleven_labs_text2speech(**kwargs: Any) -> BaseTool: + return ElevenLabsText2SpeechTool(**kwargs) + + +def _get_memorize(llm: BaseLanguageModel, **kwargs: Any) -> BaseTool: + return Memorize(llm=llm) # type: ignore[arg-type] + + +def _get_google_cloud_texttospeech(**kwargs: Any) -> BaseTool: + return GoogleCloudTextToSpeechTool(**kwargs) + + +def _get_file_management_tool(**kwargs: Any) -> BaseTool: + return ReadFileTool(**kwargs) + + +def _get_reddit_search(**kwargs: Any) -> BaseTool: + return RedditSearchRun(api_wrapper=RedditSearchAPIWrapper(**kwargs)) + + +_EXTRA_LLM_TOOLS: Dict[ + str, + Tuple[Callable[[Arg(BaseLanguageModel, "llm"), KwArg(Any)], BaseTool], List[str]], +] = { + "news-api": (_get_news_api, ["news_api_key"]), + "tmdb-api": (_get_tmdb_api, ["tmdb_bearer_token"]), + "podcast-api": (_get_podcast_api, ["listen_api_key"]), + "memorize": (_get_memorize, []), +} +_EXTRA_OPTIONAL_TOOLS: Dict[str, Tuple[Callable[[KwArg(Any)], BaseTool], List[str]]] = { + "wolfram-alpha": (_get_wolfram_alpha, ["wolfram_alpha_appid"]), + "google-search": (_get_google_search, ["google_api_key", "google_cse_id"]), + "google-search-results-json": ( + _get_google_search_results_json, + ["google_api_key", "google_cse_id", "num_results"], + ), + "searx-search-results-json": ( + _get_searx_search_results_json, + ["searx_host", "engines", "num_results", "aiosession"], + ), + "bing-search": (_get_bing_search, ["bing_subscription_key", "bing_search_url"]), + "metaphor-search": (_get_metaphor_search, ["metaphor_api_key"]), + "ddg-search": (_get_ddg_search, []), + "google-books": (_get_google_books, ["google_books_api_key"]), + "google-lens": (_get_google_lens, ["serp_api_key"]), + "google-serper": (_get_google_serper, ["serper_api_key", "aiosession"]), + "google-scholar": ( + _get_google_scholar, + ["top_k_results", "hl", "lr", "serp_api_key"], + ), + "google-finance": ( + _get_google_finance, + ["serp_api_key"], + ), + "google-trends": ( + _get_google_trends, + ["serp_api_key"], + ), + "google-jobs": ( + _get_google_jobs, + ["serp_api_key"], + ), + "google-serper-results-json": ( + _get_google_serper_results_json, + ["serper_api_key", "aiosession"], + ), + "searchapi": (_get_searchapi, ["searchapi_api_key", "aiosession"]), + "searchapi-results-json": ( + _get_searchapi_results_json, + ["searchapi_api_key", "aiosession"], + ), + "serpapi": (_get_serpapi, ["serpapi_api_key", "aiosession"]), + "dalle-image-generator": (_get_dalle_image_generator, ["openai_api_key"]), + "twilio": (_get_twilio, ["account_sid", "auth_token", "from_number"]), + "searx-search": (_get_searx_search, ["searx_host", "engines", "aiosession"]), + "merriam-webster": (_get_merriam_webster, ["merriam_webster_api_key"]), + "wikipedia": (_get_wikipedia, ["top_k_results", "lang"]), + "arxiv": ( + _get_arxiv, + ["top_k_results", "load_max_docs", "load_all_available_meta"], + ), + "golden-query": (_get_golden_query, ["golden_api_key"]), + "pubmed": (_get_pubmed, ["top_k_results"]), + "human": (_get_human_tool, ["prompt_func", "input_func"]), + "awslambda": ( + _get_lambda_api, + ["awslambda_tool_name", "awslambda_tool_description", "function_name"], + ), + "stackexchange": (_get_stackexchange, []), + "sceneXplain": (_get_scenexplain, []), + "graphql": ( + _get_graphql_tool, + ["graphql_endpoint", "custom_headers", "fetch_schema_from_transport"], + ), + "openweathermap-api": (_get_openweathermap, ["openweathermap_api_key"]), + "dataforseo-api-search": ( + _get_dataforseo_api_search, + ["api_login", "api_password", "aiosession"], + ), + "dataforseo-api-search-json": ( + _get_dataforseo_api_search_json, + ["api_login", "api_password", "aiosession"], + ), + "eleven_labs_text2speech": (_get_eleven_labs_text2speech, ["elevenlabs_api_key"]), + "google_cloud_texttospeech": (_get_google_cloud_texttospeech, []), + "read_file": (_get_file_management_tool, []), + "reddit_search": ( + _get_reddit_search, + ["reddit_client_id", "reddit_client_secret", "reddit_user_agent"], + ), +} + + +def _handle_callbacks( + callback_manager: Optional[BaseCallbackManager], callbacks: Callbacks +) -> Callbacks: + if callback_manager is not None: + warnings.warn( + "callback_manager is deprecated. Please use callbacks instead.", + DeprecationWarning, + ) + if callbacks is not None: + raise ValueError( + "Cannot specify both callback_manager and callbacks arguments." + ) + return callback_manager + return callbacks + + +def load_huggingface_tool( + task_or_repo_id: str, + model_repo_id: Optional[str] = None, + token: Optional[str] = None, + remote: bool = False, + **kwargs: Any, +) -> BaseTool: + """Loads a tool from the HuggingFace Hub. + + Args: + task_or_repo_id: Task or model repo id. + model_repo_id: Optional model repo id. Defaults to None. + token: Optional token. Defaults to None. + remote: Optional remote. Defaults to False. + kwargs: Additional keyword arguments. + + Returns: + A tool. + + Raises: + ImportError: If the required libraries are not installed. + NotImplementedError: If multimodal outputs or inputs are not supported. + """ + try: + from transformers import load_tool + except ImportError: + raise ImportError( + "HuggingFace tools require the libraries `transformers>=4.29.0`" + " and `huggingface_hub>=0.14.1` to be installed." + " Please install it with" + " `pip install --upgrade transformers huggingface_hub`." + ) + hf_tool = load_tool( + task_or_repo_id, + model_repo_id=model_repo_id, + token=token, + remote=remote, + **kwargs, + ) + outputs = hf_tool.outputs + if set(outputs) != {"text"}: + raise NotImplementedError("Multimodal outputs not supported yet.") + inputs = hf_tool.inputs + if set(inputs) != {"text"}: + raise NotImplementedError("Multimodal inputs not supported yet.") + return Tool.from_function( + hf_tool.__call__, name=hf_tool.name, description=hf_tool.description + ) + + +def raise_dangerous_tools_exception(name: str) -> None: + raise ValueError( + f"{name} is a dangerous tool. You cannot use it without opting in " + "by setting allow_dangerous_tools to True. " + "Most tools have some inherit risk to them merely because they are " + 'allowed to interact with the "real world".' + "Please refer to LangChain security guidelines " + "to https://python.langchain.com/docs/security." + "Some tools have been designated as dangerous because they pose " + "risk that is not intuitively obvious. For example, a tool that " + "allows an agent to make requests to the web, can also be used " + "to make requests to a server that is only accessible from the " + "server hosting the code." + "Again, all tools carry some risk, and it's your responsibility to " + "understand which tools you're using and the risks associated with " + "them." + ) + + +def load_tools( + tool_names: List[str], + llm: Optional[BaseLanguageModel] = None, + callbacks: Callbacks = None, + allow_dangerous_tools: bool = False, + **kwargs: Any, +) -> List[BaseTool]: + """Load tools based on their name. + + Tools allow agents to interact with various resources and services like + APIs, databases, file systems, etc. + + Please scope the permissions of each tools to the minimum required for the + application. + + For example, if an application only needs to read from a database, + the database tool should not be given write permissions. Moreover + consider scoping the permissions to only allow accessing specific + tables and impose user-level quota for limiting resource usage. + + Please read the APIs of the individual tools to determine which configuration + they support. + + See [Security](https://python.langchain.com/docs/security) for more information. + + Args: + tool_names: name of tools to load. + llm: An optional language model may be needed to initialize certain tools. + Defaults to None. + callbacks: Optional callback manager or list of callback handlers. + If not provided, default global callback manager will be used. + allow_dangerous_tools: Optional flag to allow dangerous tools. + Tools that contain some level of risk. + Please use with caution and read the documentation of these tools + to understand the risks and how to mitigate them. + Refer to https://python.langchain.com/docs/security + for more information. + Please note that this list may not be fully exhaustive. + It is your responsibility to understand which tools + you're using and the risks associated with them. + Defaults to False. + kwargs: Additional keyword arguments. + + Returns: + List of tools. + + Raises: + ValueError: If the tool name is unknown. + ValueError: If the tool requires an LLM to be provided. + ValueError: If the tool requires some parameters that were not provided. + ValueError: If the tool is a dangerous tool and allow_dangerous_tools is False. + """ + tools = [] + callbacks = _handle_callbacks( + callback_manager=kwargs.get("callback_manager"), callbacks=callbacks + ) + for name in tool_names: + if name in DANGEROUS_TOOLS and not allow_dangerous_tools: + raise_dangerous_tools_exception(name) + + if name in {"requests"}: + warnings.warn( + "tool name `requests` is deprecated - " + "please use `requests_all` or specify the requests method" + ) + if name == "requests_all": + # expand requests into various methods + if not allow_dangerous_tools: + raise_dangerous_tools_exception(name) + requests_method_tools = [ + _tool for _tool in DANGEROUS_TOOLS if _tool.startswith("requests_") + ] + tool_names.extend(requests_method_tools) + elif name in _BASE_TOOLS: + tools.append(_BASE_TOOLS[name]()) + elif name in DANGEROUS_TOOLS: + tools.append(DANGEROUS_TOOLS[name]()) + elif name in _LLM_TOOLS: + if llm is None: + raise ValueError(f"Tool {name} requires an LLM to be provided") + tool = _LLM_TOOLS[name](llm) + tools.append(tool) + elif name in _EXTRA_LLM_TOOLS: + if llm is None: + raise ValueError(f"Tool {name} requires an LLM to be provided") + _get_llm_tool_func, extra_keys = _EXTRA_LLM_TOOLS[name] + missing_keys = set(extra_keys).difference(kwargs) + if missing_keys: + raise ValueError( + f"Tool {name} requires some parameters that were not " + f"provided: {missing_keys}" + ) + sub_kwargs = {k: kwargs[k] for k in extra_keys} + tool = _get_llm_tool_func(llm=llm, **sub_kwargs) + tools.append(tool) + elif name in _EXTRA_OPTIONAL_TOOLS: + _get_tool_func, extra_keys = _EXTRA_OPTIONAL_TOOLS[name] + sub_kwargs = {k: kwargs[k] for k in extra_keys if k in kwargs} + tool = _get_tool_func(**sub_kwargs) + tools.append(tool) + else: + raise ValueError(f"Got unknown tool {name}") + if callbacks is not None: + for tool in tools: + tool.callbacks = callbacks + return tools + + +def get_all_tool_names() -> List[str]: + """Get a list of all possible tool names.""" + return ( + list(_BASE_TOOLS) + + list(_EXTRA_OPTIONAL_TOOLS) + + list(_EXTRA_LLM_TOOLS) + + list(_LLM_TOOLS) + + list(DANGEROUS_TOOLS) + ) diff --git a/python/user_packages/Python313/site-packages/langchain_community/agents/__init__.py b/python/user_packages/Python313/site-packages/langchain_community/agents/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/__init__.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5d36b91f4b1d946906c1eddcde9b968a075f3228 --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/__init__.py @@ -0,0 +1,157 @@ +"""**Callback handlers** allow listening to events in LangChain. + +**Class hierarchy:** + +.. code-block:: + + BaseCallbackHandler --> CallbackHandler # Example: AimCallbackHandler +""" + +import importlib +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from langchain_community.callbacks.aim_callback import ( + AimCallbackHandler, + ) + from langchain_community.callbacks.argilla_callback import ( + ArgillaCallbackHandler, + ) + from langchain_community.callbacks.arize_callback import ( + ArizeCallbackHandler, + ) + from langchain_community.callbacks.arthur_callback import ( + ArthurCallbackHandler, + ) + from langchain_community.callbacks.clearml_callback import ( + ClearMLCallbackHandler, + ) + from langchain_community.callbacks.comet_ml_callback import ( + CometCallbackHandler, + ) + from langchain_community.callbacks.context_callback import ( + ContextCallbackHandler, + ) + from langchain_community.callbacks.fiddler_callback import ( + FiddlerCallbackHandler, + ) + from langchain_community.callbacks.flyte_callback import ( + FlyteCallbackHandler, + ) + from langchain_community.callbacks.human import ( + HumanApprovalCallbackHandler, + ) + from langchain_community.callbacks.infino_callback import ( + InfinoCallbackHandler, + ) + from langchain_community.callbacks.labelstudio_callback import ( + LabelStudioCallbackHandler, + ) + from langchain_community.callbacks.llmonitor_callback import ( + LLMonitorCallbackHandler, + ) + from langchain_community.callbacks.manager import ( + get_openai_callback, + wandb_tracing_enabled, + ) + from langchain_community.callbacks.mlflow_callback import ( + MlflowCallbackHandler, + ) + from langchain_community.callbacks.openai_info import ( + OpenAICallbackHandler, + ) + from langchain_community.callbacks.promptlayer_callback import ( + PromptLayerCallbackHandler, + ) + from langchain_community.callbacks.sagemaker_callback import ( + SageMakerCallbackHandler, + ) + from langchain_community.callbacks.streamlit import ( + LLMThoughtLabeler, + StreamlitCallbackHandler, + ) + from langchain_community.callbacks.trubrics_callback import ( + TrubricsCallbackHandler, + ) + from langchain_community.callbacks.upstash_ratelimit_callback import ( + UpstashRatelimitError, + UpstashRatelimitHandler, # noqa: F401 + ) + from langchain_community.callbacks.uptrain_callback import ( + UpTrainCallbackHandler, + ) + from langchain_community.callbacks.wandb_callback import ( + WandbCallbackHandler, + ) + from langchain_community.callbacks.whylabs_callback import ( + WhyLabsCallbackHandler, + ) + + +_module_lookup = { + "AimCallbackHandler": "langchain_community.callbacks.aim_callback", + "ArgillaCallbackHandler": "langchain_community.callbacks.argilla_callback", + "ArizeCallbackHandler": "langchain_community.callbacks.arize_callback", + "ArthurCallbackHandler": "langchain_community.callbacks.arthur_callback", + "ClearMLCallbackHandler": "langchain_community.callbacks.clearml_callback", + "CometCallbackHandler": "langchain_community.callbacks.comet_ml_callback", + "ContextCallbackHandler": "langchain_community.callbacks.context_callback", + "FiddlerCallbackHandler": "langchain_community.callbacks.fiddler_callback", + "FlyteCallbackHandler": "langchain_community.callbacks.flyte_callback", + "HumanApprovalCallbackHandler": "langchain_community.callbacks.human", + "InfinoCallbackHandler": "langchain_community.callbacks.infino_callback", + "LLMThoughtLabeler": "langchain_community.callbacks.streamlit", + "LLMonitorCallbackHandler": "langchain_community.callbacks.llmonitor_callback", + "LabelStudioCallbackHandler": "langchain_community.callbacks.labelstudio_callback", + "MlflowCallbackHandler": "langchain_community.callbacks.mlflow_callback", + "OpenAICallbackHandler": "langchain_community.callbacks.openai_info", + "PromptLayerCallbackHandler": "langchain_community.callbacks.promptlayer_callback", + "SageMakerCallbackHandler": "langchain_community.callbacks.sagemaker_callback", + "StreamlitCallbackHandler": "langchain_community.callbacks.streamlit", + "TrubricsCallbackHandler": "langchain_community.callbacks.trubrics_callback", + "UpstashRatelimitError": "langchain_community.callbacks.upstash_ratelimit_callback", + "UpstashRatelimitHandler": "langchain_community.callbacks.upstash_ratelimit_callback", # noqa + "UpTrainCallbackHandler": "langchain_community.callbacks.uptrain_callback", + "WandbCallbackHandler": "langchain_community.callbacks.wandb_callback", + "WhyLabsCallbackHandler": "langchain_community.callbacks.whylabs_callback", + "get_openai_callback": "langchain_community.callbacks.manager", + "wandb_tracing_enabled": "langchain_community.callbacks.manager", +} + + +def __getattr__(name: str) -> Any: + if name in _module_lookup: + module = importlib.import_module(_module_lookup[name]) + return getattr(module, name) + raise AttributeError(f"module {__name__} has no attribute {name}") + + +__all__ = [ + "AimCallbackHandler", + "ArgillaCallbackHandler", + "ArizeCallbackHandler", + "ArthurCallbackHandler", + "ClearMLCallbackHandler", + "CometCallbackHandler", + "ContextCallbackHandler", + "FiddlerCallbackHandler", + "FlyteCallbackHandler", + "HumanApprovalCallbackHandler", + "InfinoCallbackHandler", + "LLMThoughtLabeler", + "LLMonitorCallbackHandler", + "LabelStudioCallbackHandler", + "MlflowCallbackHandler", + "OpenAICallbackHandler", + "PromptLayerCallbackHandler", + "SageMakerCallbackHandler", + "StreamlitCallbackHandler", + "TrubricsCallbackHandler", + "UpstashRatelimitError", + "UpstashRatelimitHandler", + "UpTrainCallbackHandler", + "WandbCallbackHandler", + "WhyLabsCallbackHandler", + "get_openai_callback", + "wandb_tracing_enabled", +] diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/aim_callback.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/aim_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..e5d1aa50fec3fcae6a7cddbf7d0568555530050c --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/aim_callback.py @@ -0,0 +1,434 @@ +from copy import deepcopy +from typing import Any, Dict, List, Optional + +from langchain_core.agents import AgentAction, AgentFinish +from langchain_core.callbacks import BaseCallbackHandler +from langchain_core.outputs import LLMResult +from langchain_core.utils import guard_import + + +def import_aim() -> Any: + """Import the aim python package and raise an error if it is not installed.""" + return guard_import("aim") + + +class BaseMetadataCallbackHandler: + """Callback handler for the metadata and associated function states for callbacks. + + Attributes: + step (int): The current step. + starts (int): The number of times the start method has been called. + ends (int): The number of times the end method has been called. + errors (int): The number of times the error method has been called. + text_ctr (int): The number of times the text method has been called. + ignore_llm_ (bool): Whether to ignore llm callbacks. + ignore_chain_ (bool): Whether to ignore chain callbacks. + ignore_agent_ (bool): Whether to ignore agent callbacks. + ignore_retriever_ (bool): Whether to ignore retriever callbacks. + always_verbose_ (bool): Whether to always be verbose. + chain_starts (int): The number of times the chain start method has been called. + chain_ends (int): The number of times the chain end method has been called. + llm_starts (int): The number of times the llm start method has been called. + llm_ends (int): The number of times the llm end method has been called. + llm_streams (int): The number of times the text method has been called. + tool_starts (int): The number of times the tool start method has been called. + tool_ends (int): The number of times the tool end method has been called. + agent_ends (int): The number of times the agent end method has been called. + """ + + def __init__(self) -> None: + self.step = 0 + + self.starts = 0 + self.ends = 0 + self.errors = 0 + self.text_ctr = 0 + + self.ignore_llm_ = False + self.ignore_chain_ = False + self.ignore_agent_ = False + self.ignore_retriever_ = False + self.always_verbose_ = False + + self.chain_starts = 0 + self.chain_ends = 0 + + self.llm_starts = 0 + self.llm_ends = 0 + self.llm_streams = 0 + + self.tool_starts = 0 + self.tool_ends = 0 + + self.agent_ends = 0 + + @property + def always_verbose(self) -> bool: + """Whether to call verbose callbacks even if verbose is False.""" + return self.always_verbose_ + + @property + def ignore_llm(self) -> bool: + """Whether to ignore LLM callbacks.""" + return self.ignore_llm_ + + @property + def ignore_chain(self) -> bool: + """Whether to ignore chain callbacks.""" + return self.ignore_chain_ + + @property + def ignore_agent(self) -> bool: + """Whether to ignore agent callbacks.""" + return self.ignore_agent_ + + @property + def ignore_retriever(self) -> bool: + """Whether to ignore retriever callbacks.""" + return self.ignore_retriever_ + + def get_custom_callback_meta(self) -> Dict[str, Any]: + return { + "step": self.step, + "starts": self.starts, + "ends": self.ends, + "errors": self.errors, + "text_ctr": self.text_ctr, + "chain_starts": self.chain_starts, + "chain_ends": self.chain_ends, + "llm_starts": self.llm_starts, + "llm_ends": self.llm_ends, + "llm_streams": self.llm_streams, + "tool_starts": self.tool_starts, + "tool_ends": self.tool_ends, + "agent_ends": self.agent_ends, + } + + def reset_callback_meta(self) -> None: + """Reset the callback metadata.""" + self.step = 0 + + self.starts = 0 + self.ends = 0 + self.errors = 0 + self.text_ctr = 0 + + self.ignore_llm_ = False + self.ignore_chain_ = False + self.ignore_agent_ = False + self.always_verbose_ = False + + self.chain_starts = 0 + self.chain_ends = 0 + + self.llm_starts = 0 + self.llm_ends = 0 + self.llm_streams = 0 + + self.tool_starts = 0 + self.tool_ends = 0 + + self.agent_ends = 0 + + return None + + +class AimCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler): + """Callback Handler that logs to Aim. + + Parameters: + repo (:obj:`str`, optional): Aim repository path or Repo object to which + Run object is bound. If skipped, default Repo is used. + experiment_name (:obj:`str`, optional): Sets Run's `experiment` property. + 'default' if not specified. Can be used later to query runs/sequences. + system_tracking_interval (:obj:`int`, optional): Sets the tracking interval + in seconds for system usage metrics (CPU, Memory, etc.). Set to `None` + to disable system metrics tracking. + log_system_params (:obj:`bool`, optional): Enable/Disable logging of system + params such as installed packages, git info, environment variables, etc. + + This handler will utilize the associated callback method called and formats + the input of each callback function with metadata regarding the state of LLM run + and then logs the response to Aim. + """ + + def __init__( + self, + repo: Optional[str] = None, + experiment_name: Optional[str] = None, + system_tracking_interval: Optional[int] = 10, + log_system_params: bool = True, + ) -> None: + """Initialize callback handler.""" + + super().__init__() + + aim = import_aim() + self.repo = repo + self.experiment_name = experiment_name + self.system_tracking_interval = system_tracking_interval + self.log_system_params = log_system_params + self._run = aim.Run( + repo=self.repo, + experiment=self.experiment_name, + system_tracking_interval=self.system_tracking_interval, + log_system_params=self.log_system_params, + ) + self._run_hash = self._run.hash + self.action_records: list = [] + + def setup(self, **kwargs: Any) -> None: + aim = import_aim() + + if not self._run: + if self._run_hash: + self._run = aim.Run( + self._run_hash, + repo=self.repo, + system_tracking_interval=self.system_tracking_interval, + ) + else: + self._run = aim.Run( + repo=self.repo, + experiment=self.experiment_name, + system_tracking_interval=self.system_tracking_interval, + log_system_params=self.log_system_params, + ) + self._run_hash = self._run.hash + + if kwargs: + for key, value in kwargs.items(): + self._run.set(key, value, strict=False) + + def on_llm_start( + self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any + ) -> None: + """Run when LLM starts.""" + aim = import_aim() + + self.step += 1 + self.llm_starts += 1 + self.starts += 1 + + resp = {"action": "on_llm_start"} + resp.update(self.get_custom_callback_meta()) + + prompts_res = deepcopy(prompts) + + self._run.track( + [aim.Text(prompt) for prompt in prompts_res], + name="on_llm_start", + context=resp, + ) + + def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None: + """Run when LLM ends running.""" + aim = import_aim() + self.step += 1 + self.llm_ends += 1 + self.ends += 1 + + resp = {"action": "on_llm_end"} + resp.update(self.get_custom_callback_meta()) + + response_res = deepcopy(response) + + generated = [ + aim.Text(generation.text) + for generations in response_res.generations + for generation in generations + ] + self._run.track( + generated, + name="on_llm_end", + context=resp, + ) + + def on_llm_new_token(self, token: str, **kwargs: Any) -> None: + """Run when LLM generates a new token.""" + self.step += 1 + self.llm_streams += 1 + + def on_llm_error(self, error: BaseException, **kwargs: Any) -> None: + """Run when LLM errors.""" + self.step += 1 + self.errors += 1 + + def on_chain_start( + self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any + ) -> None: + """Run when chain starts running.""" + aim = import_aim() + self.step += 1 + self.chain_starts += 1 + self.starts += 1 + + resp = {"action": "on_chain_start"} + resp.update(self.get_custom_callback_meta()) + + inputs_res = deepcopy(inputs) + + self._run.track( + aim.Text(inputs_res["input"]), name="on_chain_start", context=resp + ) + + def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None: + """Run when chain ends running.""" + aim = import_aim() + self.step += 1 + self.chain_ends += 1 + self.ends += 1 + + resp = {"action": "on_chain_end"} + resp.update(self.get_custom_callback_meta()) + + outputs_res = deepcopy(outputs) + + self._run.track( + aim.Text(outputs_res["output"]), name="on_chain_end", context=resp + ) + + def on_chain_error(self, error: BaseException, **kwargs: Any) -> None: + """Run when chain errors.""" + self.step += 1 + self.errors += 1 + + def on_tool_start( + self, serialized: Dict[str, Any], input_str: str, **kwargs: Any + ) -> None: + """Run when tool starts running.""" + aim = import_aim() + self.step += 1 + self.tool_starts += 1 + self.starts += 1 + + resp = {"action": "on_tool_start"} + resp.update(self.get_custom_callback_meta()) + + self._run.track(aim.Text(input_str), name="on_tool_start", context=resp) + + def on_tool_end(self, output: Any, **kwargs: Any) -> None: + """Run when tool ends running.""" + output = str(output) + aim = import_aim() + self.step += 1 + self.tool_ends += 1 + self.ends += 1 + + resp = {"action": "on_tool_end"} + resp.update(self.get_custom_callback_meta()) + + self._run.track(aim.Text(output), name="on_tool_end", context=resp) + + def on_tool_error(self, error: BaseException, **kwargs: Any) -> None: + """Run when tool errors.""" + self.step += 1 + self.errors += 1 + + def on_text(self, text: str, **kwargs: Any) -> None: + """ + Run when agent is ending. + """ + self.step += 1 + self.text_ctr += 1 + + def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None: + """Run when agent ends running.""" + aim = import_aim() + self.step += 1 + self.agent_ends += 1 + self.ends += 1 + + resp = {"action": "on_agent_finish"} + resp.update(self.get_custom_callback_meta()) + + finish_res = deepcopy(finish) + + text = "OUTPUT:\n{}\n\nLOG:\n{}".format( + finish_res.return_values["output"], finish_res.log + ) + self._run.track(aim.Text(text), name="on_agent_finish", context=resp) + + def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any: + """Run on agent action.""" + aim = import_aim() + self.step += 1 + self.tool_starts += 1 + self.starts += 1 + + resp = { + "action": "on_agent_action", + "tool": action.tool, + } + resp.update(self.get_custom_callback_meta()) + + action_res = deepcopy(action) + + text = "TOOL INPUT:\n{}\n\nLOG:\n{}".format( + action_res.tool_input, action_res.log + ) + self._run.track(aim.Text(text), name="on_agent_action", context=resp) + + def flush_tracker( + self, + repo: Optional[str] = None, + experiment_name: Optional[str] = None, + system_tracking_interval: Optional[int] = 10, + log_system_params: bool = True, + langchain_asset: Any = None, + reset: bool = True, + finish: bool = False, + ) -> None: + """Flush the tracker and reset the session. + + Args: + repo (:obj:`str`, optional): Aim repository path or Repo object to which + Run object is bound. If skipped, default Repo is used. + experiment_name (:obj:`str`, optional): Sets Run's `experiment` property. + 'default' if not specified. Can be used later to query runs/sequences. + system_tracking_interval (:obj:`int`, optional): Sets the tracking interval + in seconds for system usage metrics (CPU, Memory, etc.). Set to `None` + to disable system metrics tracking. + log_system_params (:obj:`bool`, optional): Enable/Disable logging of system + params such as installed packages, git info, environment variables, etc. + langchain_asset: The langchain asset to save. + reset: Whether to reset the session. + finish: Whether to finish the run. + + Returns: + None + """ + + if langchain_asset: + try: + for key, value in langchain_asset.dict().items(): + self._run.set(key, value, strict=False) + except Exception: + pass + + if finish or reset: + self._run.close() + self.reset_callback_meta() + if reset: + aim = import_aim() + self.repo = repo if repo else self.repo + self.experiment_name = ( + experiment_name if experiment_name else self.experiment_name + ) + self.system_tracking_interval = ( + system_tracking_interval + if system_tracking_interval + else self.system_tracking_interval + ) + self.log_system_params = ( + log_system_params if log_system_params else self.log_system_params + ) + + self._run = aim.Run( + repo=self.repo, + experiment=self.experiment_name, + system_tracking_interval=self.system_tracking_interval, + log_system_params=self.log_system_params, + ) + self._run_hash = self._run.hash + self.action_records = [] diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/argilla_callback.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/argilla_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..9cd005c5cb15255866abde9f0568c77baddbeaeb --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/argilla_callback.py @@ -0,0 +1,349 @@ +import os +import warnings +from typing import Any, Dict, List, Optional, cast + +from langchain_core.agents import AgentAction, AgentFinish +from langchain_core.callbacks import BaseCallbackHandler +from langchain_core.outputs import LLMResult +from packaging.version import parse + + +class ArgillaCallbackHandler(BaseCallbackHandler): + """Callback Handler that logs into Argilla. + + Args: + dataset_name: name of the `FeedbackDataset` in Argilla. Note that it must + exist in advance. If you need help on how to create a `FeedbackDataset` in + Argilla, please visit + https://docs.argilla.io/en/latest/tutorials_and_integrations/integrations/use_argilla_callback_in_langchain.html. + workspace_name: name of the workspace in Argilla where the specified + `FeedbackDataset` lives in. Defaults to `None`, which means that the + default workspace will be used. + api_url: URL of the Argilla Server that we want to use, and where the + `FeedbackDataset` lives in. Defaults to `None`, which means that either + `ARGILLA_API_URL` environment variable or the default will be used. + api_key: API Key to connect to the Argilla Server. Defaults to `None`, which + means that either `ARGILLA_API_KEY` environment variable or the default + will be used. + + Raises: + ImportError: if the `argilla` package is not installed. + ConnectionError: if the connection to Argilla fails. + FileNotFoundError: if the `FeedbackDataset` retrieval from Argilla fails. + + Examples: + >>> from langchain_community.llms import OpenAI + >>> from langchain_community.callbacks import ArgillaCallbackHandler + >>> argilla_callback = ArgillaCallbackHandler( + ... dataset_name="my-dataset", + ... workspace_name="my-workspace", + ... api_url="http://localhost:6900", + ... api_key="argilla.apikey", + ... ) + >>> llm = OpenAI( + ... temperature=0, + ... callbacks=[argilla_callback], + ... verbose=True, + ... openai_api_key="API_KEY_HERE", + ... ) + >>> llm.generate([ + ... "What is the best NLP-annotation tool out there? (no bias at all)", + ... ]) + "Argilla, no doubt about it." + """ + + REPO_URL: str = "https://github.com/argilla-io/argilla" + ISSUES_URL: str = f"{REPO_URL}/issues" + BLOG_URL: str = "https://docs.argilla.io/en/latest/tutorials_and_integrations/integrations/use_argilla_callback_in_langchain.html" + + DEFAULT_API_URL: str = "http://localhost:6900" + + def __init__( + self, + dataset_name: str, + workspace_name: Optional[str] = None, + api_url: Optional[str] = None, + api_key: Optional[str] = None, + ) -> None: + """Initializes the `ArgillaCallbackHandler`. + + Args: + dataset_name: name of the `FeedbackDataset` in Argilla. Note that it must + exist in advance. If you need help on how to create a `FeedbackDataset` + in Argilla, please visit + https://docs.argilla.io/en/latest/tutorials_and_integrations/integrations/use_argilla_callback_in_langchain.html. + workspace_name: name of the workspace in Argilla where the specified + `FeedbackDataset` lives in. Defaults to `None`, which means that the + default workspace will be used. + api_url: URL of the Argilla Server that we want to use, and where the + `FeedbackDataset` lives in. Defaults to `None`, which means that either + `ARGILLA_API_URL` environment variable or the default will be used. + api_key: API Key to connect to the Argilla Server. Defaults to `None`, which + means that either `ARGILLA_API_KEY` environment variable or the default + will be used. + + Raises: + ImportError: if the `argilla` package is not installed. + ConnectionError: if the connection to Argilla fails. + FileNotFoundError: if the `FeedbackDataset` retrieval from Argilla fails. + """ + + super().__init__() + + # Import Argilla (not via `import_argilla` to keep hints in IDEs) + try: + import argilla as rg + + self.ARGILLA_VERSION = rg.__version__ + except ImportError: + raise ImportError( + "To use the Argilla callback manager you need to have the `argilla` " + "Python package installed. Please install it with `pip install argilla`" + ) + + # Check whether the Argilla version is compatible + if parse(self.ARGILLA_VERSION) < parse("1.8.0"): + raise ImportError( + f"The installed `argilla` version is {self.ARGILLA_VERSION} but " + "`ArgillaCallbackHandler` requires at least version 1.8.0. Please " + "upgrade `argilla` with `pip install --upgrade argilla`." + ) + + # Show a warning message if Argilla will assume the default values will be used + if api_url is None and os.getenv("ARGILLA_API_URL") is None: + warnings.warn( + ( + "Since `api_url` is None, and the env var `ARGILLA_API_URL` is not" + f" set, it will default to `{self.DEFAULT_API_URL}`, which is the" + " default API URL in Argilla Quickstart." + ), + ) + api_url = self.DEFAULT_API_URL + + if api_key is None and os.getenv("ARGILLA_API_KEY") is None: + self.DEFAULT_API_KEY = ( + "admin.apikey" + if parse(self.ARGILLA_VERSION) < parse("1.11.0") + else "owner.apikey" + ) + + warnings.warn( + ( + "Since `api_key` is None, and the env var `ARGILLA_API_KEY` is not" + f" set, it will default to `{self.DEFAULT_API_KEY}`, which is the" + " default API key in Argilla Quickstart." + ), + ) + api_key = self.DEFAULT_API_KEY + + # Connect to Argilla with the provided credentials, if applicable + try: + rg.init(api_key=api_key, api_url=api_url) + except Exception as e: + raise ConnectionError( + f"Could not connect to Argilla with exception: '{e}'.\n" + "Please check your `api_key` and `api_url`, and make sure that " + "the Argilla server is up and running. If the problem persists " + f"please report it to {self.ISSUES_URL} as an `integration` issue." + ) from e + + # Set the Argilla variables + self.dataset_name = dataset_name + self.workspace_name = workspace_name or rg.get_workspace() + + # Retrieve the `FeedbackDataset` from Argilla (without existing records) + try: + extra_args = {} + if parse(self.ARGILLA_VERSION) < parse("1.14.0"): + warnings.warn( + f"You have Argilla {self.ARGILLA_VERSION}, but Argilla 1.14.0 or" + " higher is recommended.", + UserWarning, + ) + extra_args = {"with_records": False} + self.dataset = rg.FeedbackDataset.from_argilla( + name=self.dataset_name, + workspace=self.workspace_name, + **extra_args, + ) + except Exception as e: + raise FileNotFoundError( + f"`FeedbackDataset` retrieval from Argilla failed with exception `{e}`." + f"\nPlease check that the dataset with name={self.dataset_name} in the" + f" workspace={self.workspace_name} exists in advance. If you need help" + " on how to create a `langchain`-compatible `FeedbackDataset` in" + f" Argilla, please visit {self.BLOG_URL}. If the problem persists" + f" please report it to {self.ISSUES_URL} as an `integration` issue." + ) from e + + supported_fields = ["prompt", "response"] + if supported_fields != [field.name for field in self.dataset.fields]: + raise ValueError( + f"`FeedbackDataset` with name={self.dataset_name} in the workspace=" + f"{self.workspace_name} had fields that are not supported yet for the" + f"`langchain` integration. Supported fields are: {supported_fields}," + f" and the current `FeedbackDataset` fields are {[field.name for field in self.dataset.fields]}." # noqa: E501 + " For more information on how to create a `langchain`-compatible" + f" `FeedbackDataset` in Argilla, please visit {self.BLOG_URL}." + ) + + self.prompts: Dict[str, List[str]] = {} + + warnings.warn( + ( + "The `ArgillaCallbackHandler` is currently in beta and is subject to" + " change based on updates to `langchain`. Please report any issues to" + f" {self.ISSUES_URL} as an `integration` issue." + ), + ) + + def on_llm_start( + self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any + ) -> None: + """Save the prompts in memory when an LLM starts.""" + self.prompts.update({str(kwargs["parent_run_id"] or kwargs["run_id"]): prompts}) + + def on_llm_new_token(self, token: str, **kwargs: Any) -> None: + """Do nothing when a new token is generated.""" + pass + + def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None: + """Log records to Argilla when an LLM ends.""" + # Do nothing if there's a parent_run_id, since we will log the records when + # the chain ends + if kwargs["parent_run_id"]: + return + + # Creates the records and adds them to the `FeedbackDataset` + prompts = self.prompts[str(kwargs["run_id"])] + for prompt, generations in zip(prompts, response.generations): + self.dataset.add_records( + records=[ + { + "fields": { + "prompt": prompt, + "response": generation.text.strip(), + }, + } + for generation in generations + ] + ) + + # Pop current run from `self.runs` + self.prompts.pop(str(kwargs["run_id"])) + + if parse(self.ARGILLA_VERSION) < parse("1.14.0"): + # Push the records to Argilla + self.dataset.push_to_argilla() + + def on_llm_error(self, error: BaseException, **kwargs: Any) -> None: + """Do nothing when LLM outputs an error.""" + pass + + def on_chain_start( + self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any + ) -> None: + """If the key `input` is in `inputs`, then save it in `self.prompts` using + either the `parent_run_id` or the `run_id` as the key. This is done so that + we don't log the same input prompt twice, once when the LLM starts and once + when the chain starts. + """ + if "input" in inputs: + self.prompts.update( + { + str(kwargs["parent_run_id"] or kwargs["run_id"]): ( + inputs["input"] + if isinstance(inputs["input"], list) + else [inputs["input"]] + ) + } + ) + + def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None: + """If either the `parent_run_id` or the `run_id` is in `self.prompts`, then + log the outputs to Argilla, and pop the run from `self.prompts`. The behavior + differs if the output is a list or not. + """ + if not any( + key in self.prompts + for key in [str(kwargs["parent_run_id"]), str(kwargs["run_id"])] + ): + return + prompts: List = self.prompts.get(str(kwargs["parent_run_id"])) or cast( + List, self.prompts.get(str(kwargs["run_id"]), []) + ) + for chain_output_key, chain_output_val in outputs.items(): + if isinstance(chain_output_val, list): + # Creates the records and adds them to the `FeedbackDataset` + self.dataset.add_records( + records=[ + { + "fields": { + "prompt": prompt, + "response": output["text"].strip(), + }, + } + for prompt, output in zip(prompts, chain_output_val) + ] + ) + else: + # Creates the records and adds them to the `FeedbackDataset` + self.dataset.add_records( + records=[ + { + "fields": { + "prompt": " ".join(prompts), + "response": chain_output_val.strip(), + }, + } + ] + ) + + # Pop current run from `self.runs` + if str(kwargs["parent_run_id"]) in self.prompts: + self.prompts.pop(str(kwargs["parent_run_id"])) + if str(kwargs["run_id"]) in self.prompts: + self.prompts.pop(str(kwargs["run_id"])) + + if parse(self.ARGILLA_VERSION) < parse("1.14.0"): + # Push the records to Argilla + self.dataset.push_to_argilla() + + def on_chain_error(self, error: BaseException, **kwargs: Any) -> None: + """Do nothing when LLM chain outputs an error.""" + pass + + def on_tool_start( + self, + serialized: Dict[str, Any], + input_str: str, + **kwargs: Any, + ) -> None: + """Do nothing when tool starts.""" + pass + + def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any: + """Do nothing when agent takes a specific action.""" + pass + + def on_tool_end( + self, + output: Any, + observation_prefix: Optional[str] = None, + llm_prefix: Optional[str] = None, + **kwargs: Any, + ) -> None: + """Do nothing when tool ends.""" + pass + + def on_tool_error(self, error: BaseException, **kwargs: Any) -> None: + """Do nothing when tool outputs an error.""" + pass + + def on_text(self, text: str, **kwargs: Any) -> None: + """Do nothing""" + pass + + def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None: + """Do nothing""" + pass diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/arize_callback.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/arize_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..45a6a39d66aaaab27fc7cf9c529d8e2c79d08220 --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/arize_callback.py @@ -0,0 +1,213 @@ +from datetime import datetime +from typing import Any, Dict, List, Optional + +from langchain_core.agents import AgentAction, AgentFinish +from langchain_core.callbacks import BaseCallbackHandler +from langchain_core.outputs import LLMResult + +from langchain_community.callbacks.utils import import_pandas + + +class ArizeCallbackHandler(BaseCallbackHandler): + """Callback Handler that logs to Arize.""" + + def __init__( + self, + model_id: Optional[str] = None, + model_version: Optional[str] = None, + SPACE_KEY: Optional[str] = None, + API_KEY: Optional[str] = None, + ) -> None: + """Initialize callback handler.""" + + super().__init__() + self.model_id = model_id + self.model_version = model_version + self.space_key = SPACE_KEY + self.api_key = API_KEY + self.prompt_records: List[str] = [] + self.response_records: List[str] = [] + self.prediction_ids: List[str] = [] + self.pred_timestamps: List[int] = [] + self.response_embeddings: List[float] = [] + self.prompt_embeddings: List[float] = [] + self.prompt_tokens = 0 + self.completion_tokens = 0 + self.total_tokens = 0 + self.step = 0 + + from arize.pandas.embeddings import EmbeddingGenerator, UseCases + from arize.pandas.logger import Client + + self.generator = EmbeddingGenerator.from_use_case( + use_case=UseCases.NLP.SEQUENCE_CLASSIFICATION, + model_name="distilbert-base-uncased", + tokenizer_max_length=512, + batch_size=256, + ) + self.arize_client = Client(space_key=SPACE_KEY, api_key=API_KEY) + if SPACE_KEY == "SPACE_KEY" or API_KEY == "API_KEY": + raise ValueError("❌ CHANGE SPACE AND API KEYS") + else: + print("✅ Arize client setup done! Now you can start using Arize!") # noqa: T201 + + def on_llm_start( + self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any + ) -> None: + for prompt in prompts: + self.prompt_records.append(prompt.replace("\n", "")) + + def on_llm_new_token(self, token: str, **kwargs: Any) -> None: + """Do nothing.""" + pass + + def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None: + pd = import_pandas() + from arize.utils.types import ( + EmbeddingColumnNames, + Environments, + ModelTypes, + Schema, + ) + + # Safe check if 'llm_output' and 'token_usage' exist + if response.llm_output and "token_usage" in response.llm_output: + self.prompt_tokens = response.llm_output["token_usage"].get( + "prompt_tokens", 0 + ) + self.total_tokens = response.llm_output["token_usage"].get( + "total_tokens", 0 + ) + self.completion_tokens = response.llm_output["token_usage"].get( + "completion_tokens", 0 + ) + else: + self.prompt_tokens = self.total_tokens = self.completion_tokens = ( + 0 # assign default value + ) + + for generations in response.generations: + for generation in generations: + prompt = self.prompt_records[self.step] + self.step = self.step + 1 + prompt_embedding = pd.Series( + self.generator.generate_embeddings( + text_col=pd.Series(prompt.replace("\n", " ")) + ).reset_index(drop=True) + ) + + # Assigning text to response_text instead of response + response_text = generation.text.replace("\n", " ") + response_embedding = pd.Series( + self.generator.generate_embeddings( + text_col=pd.Series(generation.text.replace("\n", " ")) + ).reset_index(drop=True) + ) + pred_timestamp = datetime.now().timestamp() + + # Define the columns and data + columns = [ + "prediction_ts", + "response", + "prompt", + "response_vector", + "prompt_vector", + "prompt_token", + "completion_token", + "total_token", + ] + data = [ + [ + pred_timestamp, + response_text, + prompt, + response_embedding[0], + prompt_embedding[0], + self.prompt_tokens, + self.total_tokens, + self.completion_tokens, + ] + ] + + # Create the DataFrame + df = pd.DataFrame(data, columns=columns) + + # Declare prompt and response columns + prompt_columns = EmbeddingColumnNames( + vector_column_name="prompt_vector", data_column_name="prompt" + ) + + response_columns = EmbeddingColumnNames( + vector_column_name="response_vector", data_column_name="response" + ) + + schema = Schema( + timestamp_column_name="prediction_ts", + tag_column_names=[ + "prompt_token", + "completion_token", + "total_token", + ], + prompt_column_names=prompt_columns, + response_column_names=response_columns, + ) + + response_from_arize = self.arize_client.log( + dataframe=df, + schema=schema, + model_id=self.model_id, + model_version=self.model_version, + model_type=ModelTypes.GENERATIVE_LLM, + environment=Environments.PRODUCTION, + ) + if response_from_arize.status_code == 200: + print("✅ Successfully logged data to Arize!") # noqa: T201 + else: + print(f'❌ Logging failed "{response_from_arize.text}"') # noqa: T201 + + def on_llm_error(self, error: BaseException, **kwargs: Any) -> None: + """Do nothing.""" + pass + + def on_chain_start( + self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any + ) -> None: + pass + + def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None: + """Do nothing.""" + pass + + def on_chain_error(self, error: BaseException, **kwargs: Any) -> None: + """Do nothing.""" + pass + + def on_tool_start( + self, + serialized: Dict[str, Any], + input_str: str, + **kwargs: Any, + ) -> None: + pass + + def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any: + """Do nothing.""" + pass + + def on_tool_end( + self, + output: Any, + observation_prefix: Optional[str] = None, + llm_prefix: Optional[str] = None, + **kwargs: Any, + ) -> None: + pass + + def on_tool_error(self, error: BaseException, **kwargs: Any) -> None: + pass + + def on_text(self, text: str, **kwargs: Any) -> None: + pass + + def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None: + pass diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/arthur_callback.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/arthur_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..6aa911fd739ebdd0bde3b4612aa598b26de58dc1 --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/arthur_callback.py @@ -0,0 +1,297 @@ +"""ArthurAI's Callback Handler.""" + +from __future__ import annotations + +import os +import uuid +from collections import defaultdict +from datetime import datetime +from time import time +from typing import TYPE_CHECKING, Any, DefaultDict, Dict, List, Optional + +import numpy as np +from langchain_core.agents import AgentAction, AgentFinish +from langchain_core.callbacks import BaseCallbackHandler +from langchain_core.outputs import LLMResult + +if TYPE_CHECKING: + import arthurai + from arthurai.core.models import ArthurModel + +PROMPT_TOKENS = "prompt_tokens" +COMPLETION_TOKENS = "completion_tokens" +TOKEN_USAGE = "token_usage" +FINISH_REASON = "finish_reason" +DURATION = "duration" + + +def _lazy_load_arthur() -> arthurai: + """Lazy load Arthur.""" + try: + import arthurai + except ImportError as e: + raise ImportError( + "To use the ArthurCallbackHandler you need the" + " `arthurai` package. Please install it with" + " `pip install arthurai`.", + e, + ) + + return arthurai + + +class ArthurCallbackHandler(BaseCallbackHandler): + """Callback Handler that logs to Arthur platform. + + Arthur helps enterprise teams optimize model operations + and performance at scale. The Arthur API tracks model + performance, explainability, and fairness across tabular, + NLP, and CV models. Our API is model- and platform-agnostic, + and continuously scales with complex and dynamic enterprise needs. + To learn more about Arthur, visit our website at + https://www.arthur.ai/ or read the Arthur docs at + https://docs.arthur.ai/ + """ + + def __init__( + self, + arthur_model: ArthurModel, + ) -> None: + """Initialize callback handler.""" + super().__init__() + arthurai = _lazy_load_arthur() + Stage = arthurai.common.constants.Stage + ValueType = arthurai.common.constants.ValueType + self.arthur_model = arthur_model + # save the attributes of this model to be used when preparing + # inferences to log to Arthur in on_llm_end() + self.attr_names = set([a.name for a in self.arthur_model.get_attributes()]) + self.input_attr = [ + x + for x in self.arthur_model.get_attributes() + if x.stage == Stage.ModelPipelineInput + and x.value_type == ValueType.Unstructured_Text + ][0].name + self.output_attr = [ + x + for x in self.arthur_model.get_attributes() + if x.stage == Stage.PredictedValue + and x.value_type == ValueType.Unstructured_Text + ][0].name + self.token_likelihood_attr = None + if ( + len( + [ + x + for x in self.arthur_model.get_attributes() + if x.value_type == ValueType.TokenLikelihoods + ] + ) + > 0 + ): + self.token_likelihood_attr = [ + x + for x in self.arthur_model.get_attributes() + if x.value_type == ValueType.TokenLikelihoods + ][0].name + + self.run_map: DefaultDict[str, Any] = defaultdict(dict) + + @classmethod + def from_credentials( + cls, + model_id: str, + arthur_url: Optional[str] = "https://app.arthur.ai", + arthur_login: Optional[str] = None, + arthur_password: Optional[str] = None, + ) -> ArthurCallbackHandler: + """Initialize callback handler from Arthur credentials. + + Args: + model_id (str): The ID of the arthur model to log to. + arthur_url (str, optional): The URL of the Arthur instance to log to. + Defaults to "https://app.arthur.ai". + arthur_login (str, optional): The login to use to connect to Arthur. + Defaults to None. + arthur_password (str, optional): The password to use to connect to + Arthur. Defaults to None. + + Returns: + ArthurCallbackHandler: The initialized callback handler. + """ + arthurai = _lazy_load_arthur() + ArthurAI = arthurai.ArthurAI + ResponseClientError = arthurai.common.exceptions.ResponseClientError + + # connect to Arthur + if arthur_login is None: + try: + arthur_api_key = os.environ["ARTHUR_API_KEY"] + except KeyError: + raise ValueError( + "No Arthur authentication provided. Either give" + " a login to the ArthurCallbackHandler" + " or set an ARTHUR_API_KEY as an environment variable." + ) + arthur = ArthurAI(url=arthur_url, access_key=arthur_api_key) + else: + if arthur_password is None: + arthur = ArthurAI(url=arthur_url, login=arthur_login) + else: + arthur = ArthurAI( + url=arthur_url, login=arthur_login, password=arthur_password + ) + # get model from Arthur by the provided model ID + try: + arthur_model = arthur.get_model(model_id) + except ResponseClientError: + raise ValueError( + f"Was unable to retrieve model with id {model_id} from Arthur." + " Make sure the ID corresponds to a model that is currently" + " registered with your Arthur account." + ) + return cls(arthur_model) + + def on_llm_start( + self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any + ) -> None: + """On LLM start, save the input prompts""" + run_id = kwargs["run_id"] + self.run_map[run_id]["input_texts"] = prompts + self.run_map[run_id]["start_time"] = time() + + def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None: + """On LLM end, send data to Arthur.""" + try: + import pytz + except ImportError as e: + raise ImportError( + "Could not import pytz. Please install it with 'pip install pytz'." + ) from e + + run_id = kwargs["run_id"] + + # get the run params from this run ID, + # or raise an error if this run ID has no corresponding metadata in self.run_map + try: + run_map_data = self.run_map[run_id] + except KeyError as e: + raise KeyError( + "This function has been called with a run_id" + " that was never registered in on_llm_start()." + " Restart and try running the LLM again" + ) from e + + # mark the duration time between on_llm_start() and on_llm_end() + time_from_start_to_end = time() - run_map_data["start_time"] + + # create inferences to log to Arthur + inferences = [] + for i, generations in enumerate(response.generations): + for generation in generations: + inference = { + "partner_inference_id": str(uuid.uuid4()), + "inference_timestamp": datetime.now(tz=pytz.UTC), + self.input_attr: run_map_data["input_texts"][i], + self.output_attr: generation.text, + } + + if generation.generation_info is not None: + # add finish reason to the inference + # if generation info contains a finish reason and + # if the ArthurModel was registered to monitor finish_reason + if ( + FINISH_REASON in generation.generation_info + and FINISH_REASON in self.attr_names + ): + inference[FINISH_REASON] = generation.generation_info[ + FINISH_REASON + ] + + # add token likelihoods data to the inference if the ArthurModel + # was registered to monitor token likelihoods + logprobs_data = generation.generation_info["logprobs"] + if ( + logprobs_data is not None + and self.token_likelihood_attr is not None + ): + logprobs = logprobs_data["top_logprobs"] + likelihoods = [ + {k: np.exp(v) for k, v in logprobs[i].items()} + for i in range(len(logprobs)) + ] + inference[self.token_likelihood_attr] = likelihoods + + # add token usage counts to the inference if the + # ArthurModel was registered to monitor token usage + if ( + isinstance(response.llm_output, dict) + and TOKEN_USAGE in response.llm_output + ): + token_usage = response.llm_output[TOKEN_USAGE] + if ( + PROMPT_TOKENS in token_usage + and PROMPT_TOKENS in self.attr_names + ): + inference[PROMPT_TOKENS] = token_usage[PROMPT_TOKENS] + if ( + COMPLETION_TOKENS in token_usage + and COMPLETION_TOKENS in self.attr_names + ): + inference[COMPLETION_TOKENS] = token_usage[COMPLETION_TOKENS] + + # add inference duration to the inference if the ArthurModel + # was registered to monitor inference duration + if DURATION in self.attr_names: + inference[DURATION] = time_from_start_to_end + + inferences.append(inference) + + # send inferences to arthur + self.arthur_model.send_inferences(inferences) + + def on_chain_start( + self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any + ) -> None: + """On chain start, do nothing.""" + + def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None: + """On chain end, do nothing.""" + + def on_llm_error(self, error: BaseException, **kwargs: Any) -> None: + """Do nothing when LLM outputs an error.""" + + def on_llm_new_token(self, token: str, **kwargs: Any) -> None: + """On new token, pass.""" + + def on_chain_error(self, error: BaseException, **kwargs: Any) -> None: + """Do nothing when LLM chain outputs an error.""" + + def on_tool_start( + self, + serialized: Dict[str, Any], + input_str: str, + **kwargs: Any, + ) -> None: + """Do nothing when tool starts.""" + + def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any: + """Do nothing when agent takes a specific action.""" + + def on_tool_end( + self, + output: Any, + observation_prefix: Optional[str] = None, + llm_prefix: Optional[str] = None, + **kwargs: Any, + ) -> None: + """Do nothing when tool ends.""" + + def on_tool_error(self, error: BaseException, **kwargs: Any) -> None: + """Do nothing when tool outputs an error.""" + + def on_text(self, text: str, **kwargs: Any) -> None: + """Do nothing""" + + def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None: + """Do nothing""" diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/bedrock_anthropic_callback.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/bedrock_anthropic_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..02b1d3ed4b686a9b15f422bf831b986a16cc04fb --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/bedrock_anthropic_callback.py @@ -0,0 +1,135 @@ +import threading +from typing import Any, Dict, List, Union + +from langchain_core.callbacks import BaseCallbackHandler +from langchain_core.outputs import LLMResult + +MODEL_COST_PER_1K_INPUT_TOKENS = { + "anthropic.claude-instant-v1": 0.0008, + "anthropic.claude-v2": 0.008, + "anthropic.claude-v2:1": 0.008, + "anthropic.claude-3-sonnet-20240229-v1:0": 0.003, + "anthropic.claude-3-5-sonnet-20240620-v1:0": 0.003, + "anthropic.claude-3-5-sonnet-20241022-v2:0": 0.003, + "anthropic.claude-3-7-sonnet-20250219-v1:0": 0.003, + "anthropic.claude-sonnet-4-20250514-v1:0": 0.003, + "anthropic.claude-3-haiku-20240307-v1:0": 0.00025, + "anthropic.claude-3-opus-20240229-v1:0": 0.015, + "anthropic.claude-opus-4-20250514-v1:0": 0.015, + "anthropic.claude-3-5-haiku-20241022-v1:0": 0.0008, +} + +MODEL_COST_PER_1K_OUTPUT_TOKENS = { + "anthropic.claude-instant-v1": 0.0024, + "anthropic.claude-v2": 0.024, + "anthropic.claude-v2:1": 0.024, + "anthropic.claude-3-sonnet-20240229-v1:0": 0.015, + "anthropic.claude-3-5-sonnet-20240620-v1:0": 0.015, + "anthropic.claude-3-5-sonnet-20241022-v2:0": 0.015, + "anthropic.claude-3-7-sonnet-20250219-v1:0": 0.015, + "anthropic.claude-sonnet-4-20250514-v1:0": 0.015, + "anthropic.claude-3-haiku-20240307-v1:0": 0.00125, + "anthropic.claude-3-opus-20240229-v1:0": 0.075, + "anthropic.claude-opus-4-20250514-v1:0": 0.075, + "anthropic.claude-3-5-haiku-20241022-v1:0": 0.004, +} + + +def _get_anthropic_claude_token_cost( + prompt_tokens: int, completion_tokens: int, model_id: Union[str, None] +) -> float: + if model_id: + # The model ID can be a cross-region (system-defined) inference profile ID, + # which has a prefix indicating the region (e.g., 'us', 'eu') but + # shares the same token costs as the "base model". + # By extracting the "base model ID", by taking the last two segments + # of the model ID, we can map cross-region inference profile IDs to + # their corresponding cost entries. + base_model_id = model_id.split(".")[-2] + "." + model_id.split(".")[-1] + else: + base_model_id = None + """Get the cost of tokens for the Claude model.""" + if base_model_id not in MODEL_COST_PER_1K_INPUT_TOKENS: + raise ValueError( + f"Unknown model: {model_id}. Please provide a valid Anthropic model name." + "Known models are: " + ", ".join(MODEL_COST_PER_1K_INPUT_TOKENS.keys()) + ) + return (prompt_tokens / 1000) * MODEL_COST_PER_1K_INPUT_TOKENS[base_model_id] + ( + completion_tokens / 1000 + ) * MODEL_COST_PER_1K_OUTPUT_TOKENS[base_model_id] + + +class BedrockAnthropicTokenUsageCallbackHandler(BaseCallbackHandler): + """Callback Handler that tracks bedrock anthropic info.""" + + total_tokens: int = 0 + prompt_tokens: int = 0 + completion_tokens: int = 0 + successful_requests: int = 0 + total_cost: float = 0.0 + + def __init__(self) -> None: + super().__init__() + self._lock = threading.Lock() + + def __repr__(self) -> str: + return ( + f"Tokens Used: {self.total_tokens}\n" + f"\tPrompt Tokens: {self.prompt_tokens}\n" + f"\tCompletion Tokens: {self.completion_tokens}\n" + f"Successful Requests: {self.successful_requests}\n" + f"Total Cost (USD): ${self.total_cost}" + ) + + @property + def always_verbose(self) -> bool: + """Whether to call verbose callbacks even if verbose is False.""" + return True + + def on_llm_start( + self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any + ) -> None: + """Print out the prompts.""" + pass + + def on_llm_new_token(self, token: str, **kwargs: Any) -> None: + """Print out the token.""" + pass + + def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None: + """Collect token usage.""" + if response.llm_output is None: + return None + + if "usage" not in response.llm_output: + with self._lock: + self.successful_requests += 1 + return None + + # compute tokens and cost for this request + token_usage = response.llm_output["usage"] + completion_tokens = token_usage.get("completion_tokens", 0) + prompt_tokens = token_usage.get("prompt_tokens", 0) + total_tokens = token_usage.get("total_tokens", 0) + model_id = response.llm_output.get("model_id", None) + total_cost = _get_anthropic_claude_token_cost( + prompt_tokens=prompt_tokens, + completion_tokens=completion_tokens, + model_id=model_id, + ) + + # update shared state behind lock + with self._lock: + self.total_cost += total_cost + self.total_tokens += total_tokens + self.prompt_tokens += prompt_tokens + self.completion_tokens += completion_tokens + self.successful_requests += 1 + + def __copy__(self) -> "BedrockAnthropicTokenUsageCallbackHandler": + """Return a copy of the callback handler.""" + return self + + def __deepcopy__(self, memo: Any) -> "BedrockAnthropicTokenUsageCallbackHandler": + """Return a deep copy of the callback handler.""" + return self diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/clearml_callback.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/clearml_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..8149c1cd5cbb65a4e76bb22689c3de2c3fdc7dad --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/clearml_callback.py @@ -0,0 +1,518 @@ +from __future__ import annotations + +import tempfile +from copy import deepcopy +from pathlib import Path +from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional, Sequence + +from langchain_core.agents import AgentAction, AgentFinish +from langchain_core.callbacks import BaseCallbackHandler +from langchain_core.outputs import LLMResult +from langchain_core.utils import guard_import + +from langchain_community.callbacks.utils import ( + BaseMetadataCallbackHandler, + flatten_dict, + hash_string, + import_pandas, + import_spacy, + import_textstat, + load_json, +) + +if TYPE_CHECKING: + import pandas as pd + + +def import_clearml() -> Any: + """Import the clearml python package and raise an error if it is not installed.""" + return guard_import("clearml") + + +class ClearMLCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler): + """Callback Handler that logs to ClearML. + + Parameters: + job_type (str): The type of clearml task such as "inference", "testing" or "qc" + project_name (str): The clearml project name + tags (list): Tags to add to the task + task_name (str): Name of the clearml task + visualize (bool): Whether to visualize the run. + complexity_metrics (bool): Whether to log complexity metrics + stream_logs (bool): Whether to stream callback actions to ClearML + + This handler will utilize the associated callback method and formats + the input of each callback function with metadata regarding the state of LLM run, + and adds the response to the list of records for both the {method}_records and + action. It then logs the response to the ClearML console. + """ + + def __init__( + self, + task_type: Optional[str] = "inference", + project_name: Optional[str] = "langchain_callback_demo", + tags: Optional[Sequence] = None, + task_name: Optional[str] = None, + visualize: bool = False, + complexity_metrics: bool = False, + stream_logs: bool = False, + ) -> None: + """Initialize callback handler.""" + + clearml = import_clearml() + spacy = import_spacy() + super().__init__() + + self.task_type = task_type + self.project_name = project_name + self.tags = tags + self.task_name = task_name + self.visualize = visualize + self.complexity_metrics = complexity_metrics + self.stream_logs = stream_logs + + self.temp_dir = tempfile.TemporaryDirectory() + + # Check if ClearML task already exists (e.g. in pipeline) + if clearml.Task.current_task(): + self.task = clearml.Task.current_task() + else: + self.task = clearml.Task.init( + task_type=self.task_type, + project_name=self.project_name, + tags=self.tags, + task_name=self.task_name, + output_uri=True, + ) + self.logger = self.task.get_logger() + warning = ( + "The clearml callback is currently in beta and is subject to change " + "based on updates to `langchain`. Please report any issues to " + "https://github.com/allegroai/clearml/issues with the tag `langchain`." + ) + self.logger.report_text(warning, level=30, print_console=True) + self.callback_columns: list = [] + self.action_records: list = [] + self.complexity_metrics = complexity_metrics + self.visualize = visualize + self.nlp = spacy.load("en_core_web_sm") + + def _init_resp(self) -> Dict: + return {k: None for k in self.callback_columns} + + def on_llm_start( + self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any + ) -> None: + """Run when LLM starts.""" + self.step += 1 + self.llm_starts += 1 + self.starts += 1 + + resp = self._init_resp() + resp.update({"action": "on_llm_start"}) + resp.update(flatten_dict(serialized)) + resp.update(self.get_custom_callback_meta()) + + for prompt in prompts: + prompt_resp = deepcopy(resp) + prompt_resp["prompts"] = prompt + self.on_llm_start_records.append(prompt_resp) + self.action_records.append(prompt_resp) + if self.stream_logs: + self.logger.report_text(prompt_resp) + + def on_llm_new_token(self, token: str, **kwargs: Any) -> None: + """Run when LLM generates a new token.""" + self.step += 1 + self.llm_streams += 1 + + resp = self._init_resp() + resp.update({"action": "on_llm_new_token", "token": token}) + resp.update(self.get_custom_callback_meta()) + + self.on_llm_token_records.append(resp) + self.action_records.append(resp) + if self.stream_logs: + self.logger.report_text(resp) + + def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None: + """Run when LLM ends running.""" + self.step += 1 + self.llm_ends += 1 + self.ends += 1 + + resp = self._init_resp() + resp.update({"action": "on_llm_end"}) + resp.update(flatten_dict(response.llm_output or {})) + resp.update(self.get_custom_callback_meta()) + + for generations in response.generations: + for generation in generations: + generation_resp = deepcopy(resp) + generation_resp.update(flatten_dict(generation.dict())) + generation_resp.update(self.analyze_text(generation.text)) + self.on_llm_end_records.append(generation_resp) + self.action_records.append(generation_resp) + if self.stream_logs: + self.logger.report_text(generation_resp) + + def on_llm_error(self, error: BaseException, **kwargs: Any) -> None: + """Run when LLM errors.""" + self.step += 1 + self.errors += 1 + + def on_chain_start( + self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any + ) -> None: + """Run when chain starts running.""" + self.step += 1 + self.chain_starts += 1 + self.starts += 1 + + resp = self._init_resp() + resp.update({"action": "on_chain_start"}) + resp.update(flatten_dict(serialized)) + resp.update(self.get_custom_callback_meta()) + + chain_input = inputs.get("input", inputs.get("human_input")) + + if isinstance(chain_input, str): + input_resp = deepcopy(resp) + input_resp["input"] = chain_input + self.on_chain_start_records.append(input_resp) + self.action_records.append(input_resp) + if self.stream_logs: + self.logger.report_text(input_resp) + elif isinstance(chain_input, list): + for inp in chain_input: + input_resp = deepcopy(resp) + input_resp.update(inp) + self.on_chain_start_records.append(input_resp) + self.action_records.append(input_resp) + if self.stream_logs: + self.logger.report_text(input_resp) + else: + raise ValueError("Unexpected data format provided!") + + def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None: + """Run when chain ends running.""" + self.step += 1 + self.chain_ends += 1 + self.ends += 1 + + resp = self._init_resp() + resp.update( + { + "action": "on_chain_end", + "outputs": outputs.get("output", outputs.get("text")), + } + ) + resp.update(self.get_custom_callback_meta()) + + self.on_chain_end_records.append(resp) + self.action_records.append(resp) + if self.stream_logs: + self.logger.report_text(resp) + + def on_chain_error(self, error: BaseException, **kwargs: Any) -> None: + """Run when chain errors.""" + self.step += 1 + self.errors += 1 + + def on_tool_start( + self, serialized: Dict[str, Any], input_str: str, **kwargs: Any + ) -> None: + """Run when tool starts running.""" + self.step += 1 + self.tool_starts += 1 + self.starts += 1 + + resp = self._init_resp() + resp.update({"action": "on_tool_start", "input_str": input_str}) + resp.update(flatten_dict(serialized)) + resp.update(self.get_custom_callback_meta()) + + self.on_tool_start_records.append(resp) + self.action_records.append(resp) + if self.stream_logs: + self.logger.report_text(resp) + + def on_tool_end(self, output: Any, **kwargs: Any) -> None: + """Run when tool ends running.""" + output = str(output) + self.step += 1 + self.tool_ends += 1 + self.ends += 1 + + resp = self._init_resp() + resp.update({"action": "on_tool_end", "output": output}) + resp.update(self.get_custom_callback_meta()) + + self.on_tool_end_records.append(resp) + self.action_records.append(resp) + if self.stream_logs: + self.logger.report_text(resp) + + def on_tool_error(self, error: BaseException, **kwargs: Any) -> None: + """Run when tool errors.""" + self.step += 1 + self.errors += 1 + + def on_text(self, text: str, **kwargs: Any) -> None: + """ + Run when agent is ending. + """ + self.step += 1 + self.text_ctr += 1 + + resp = self._init_resp() + resp.update({"action": "on_text", "text": text}) + resp.update(self.get_custom_callback_meta()) + + self.on_text_records.append(resp) + self.action_records.append(resp) + if self.stream_logs: + self.logger.report_text(resp) + + def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None: + """Run when agent ends running.""" + self.step += 1 + self.agent_ends += 1 + self.ends += 1 + + resp = self._init_resp() + resp.update( + { + "action": "on_agent_finish", + "output": finish.return_values["output"], + "log": finish.log, + } + ) + resp.update(self.get_custom_callback_meta()) + + self.on_agent_finish_records.append(resp) + self.action_records.append(resp) + if self.stream_logs: + self.logger.report_text(resp) + + def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any: + """Run on agent action.""" + self.step += 1 + self.tool_starts += 1 + self.starts += 1 + + resp = self._init_resp() + resp.update( + { + "action": "on_agent_action", + "tool": action.tool, + "tool_input": action.tool_input, + "log": action.log, + } + ) + resp.update(self.get_custom_callback_meta()) + self.on_agent_action_records.append(resp) + self.action_records.append(resp) + if self.stream_logs: + self.logger.report_text(resp) + + def analyze_text(self, text: str) -> dict: + """Analyze text using textstat and spacy. + + Parameters: + text (str): The text to analyze. + + Returns: + `dict` containing the complexity metrics. + """ + resp = {} + textstat = import_textstat() + spacy = import_spacy() + if self.complexity_metrics: + text_complexity_metrics = { + "flesch_reading_ease": textstat.flesch_reading_ease(text), + "flesch_kincaid_grade": textstat.flesch_kincaid_grade(text), + "smog_index": textstat.smog_index(text), + "coleman_liau_index": textstat.coleman_liau_index(text), + "automated_readability_index": textstat.automated_readability_index( + text + ), + "dale_chall_readability_score": textstat.dale_chall_readability_score( + text + ), + "difficult_words": textstat.difficult_words(text), + "linsear_write_formula": textstat.linsear_write_formula(text), + "gunning_fog": textstat.gunning_fog(text), + "text_standard": textstat.text_standard(text), + "fernandez_huerta": textstat.fernandez_huerta(text), + "szigriszt_pazos": textstat.szigriszt_pazos(text), + "gutierrez_polini": textstat.gutierrez_polini(text), + "crawford": textstat.crawford(text), + "gulpease_index": textstat.gulpease_index(text), + "osman": textstat.osman(text), + } + resp.update(text_complexity_metrics) + + if self.visualize and self.nlp and self.temp_dir.name is not None: + doc = self.nlp(text) + + dep_out = spacy.displacy.render(doc, style="dep", jupyter=False, page=True) + dep_output_path = Path( + self.temp_dir.name, hash_string(f"dep-{text}") + ".html" + ) + dep_output_path.open("w", encoding="utf-8").write(dep_out) + + ent_out = spacy.displacy.render(doc, style="ent", jupyter=False, page=True) + ent_output_path = Path( + self.temp_dir.name, hash_string(f"ent-{text}") + ".html" + ) + ent_output_path.open("w", encoding="utf-8").write(ent_out) + + self.logger.report_media( + "Dependencies Plot", text, local_path=dep_output_path + ) + self.logger.report_media("Entities Plot", text, local_path=ent_output_path) + + return resp + + @staticmethod + def _build_llm_df( + base_df: pd.DataFrame, base_df_fields: Sequence, rename_map: Mapping + ) -> pd.DataFrame: + base_df_fields = [field for field in base_df_fields if field in base_df] + rename_map = { + map_entry_k: map_entry_v + for map_entry_k, map_entry_v in rename_map.items() + if map_entry_k in base_df_fields + } + llm_df = base_df[base_df_fields].dropna(axis=1) + if rename_map: + llm_df = llm_df.rename(rename_map, axis=1) + return llm_df + + def _create_session_analysis_df(self) -> Any: + """Create a dataframe with all the information from the session.""" + pd = import_pandas() + on_llm_end_records_df = pd.DataFrame(self.on_llm_end_records) + + llm_input_prompts_df = ClearMLCallbackHandler._build_llm_df( + base_df=on_llm_end_records_df, + base_df_fields=["step", "prompts"] + + (["name"] if "name" in on_llm_end_records_df else ["id"]), + rename_map={"step": "prompt_step"}, + ) + complexity_metrics_columns = [] + visualizations_columns: List = [] + + if self.complexity_metrics: + complexity_metrics_columns = [ + "flesch_reading_ease", + "flesch_kincaid_grade", + "smog_index", + "coleman_liau_index", + "automated_readability_index", + "dale_chall_readability_score", + "difficult_words", + "linsear_write_formula", + "gunning_fog", + "text_standard", + "fernandez_huerta", + "szigriszt_pazos", + "gutierrez_polini", + "crawford", + "gulpease_index", + "osman", + ] + + llm_outputs_df = ClearMLCallbackHandler._build_llm_df( + on_llm_end_records_df, + [ + "step", + "text", + "token_usage_total_tokens", + "token_usage_prompt_tokens", + "token_usage_completion_tokens", + ] + + complexity_metrics_columns + + visualizations_columns, + {"step": "output_step", "text": "output"}, + ) + session_analysis_df = pd.concat([llm_input_prompts_df, llm_outputs_df], axis=1) + return session_analysis_df + + def flush_tracker( + self, + name: Optional[str] = None, + langchain_asset: Any = None, + finish: bool = False, + ) -> None: + """Flush the tracker and setup the session. + + Everything after this will be a new table. + + Args: + name: Name of the performed session so far so it is identifiable + langchain_asset: The langchain asset to save. + finish: Whether to finish the run. + + Returns: + None + """ + pd = import_pandas() + clearml = import_clearml() + + # Log the action records + self.logger.report_table( + "Action Records", name, table_plot=pd.DataFrame(self.action_records) + ) + + # Session analysis + session_analysis_df = self._create_session_analysis_df() + self.logger.report_table( + "Session Analysis", name, table_plot=session_analysis_df + ) + + if self.stream_logs: + self.logger.report_text( + { + "action_records": pd.DataFrame(self.action_records), + "session_analysis": session_analysis_df, + } + ) + + if langchain_asset: + langchain_asset_path = Path(self.temp_dir.name, "model.json") + try: + langchain_asset.save(langchain_asset_path) + # Create output model and connect it to the task + output_model = clearml.OutputModel( + task=self.task, config_text=load_json(langchain_asset_path) + ) + output_model.update_weights( + weights_filename=str(langchain_asset_path), + auto_delete_file=False, + target_filename=name, + ) + except ValueError: + langchain_asset.save_agent(langchain_asset_path) + output_model = clearml.OutputModel( + task=self.task, config_text=load_json(langchain_asset_path) + ) + output_model.update_weights( + weights_filename=str(langchain_asset_path), + auto_delete_file=False, + target_filename=name, + ) + except NotImplementedError as e: + print("Could not save model.") # noqa: T201 + print(repr(e)) # noqa: T201 + pass + + # Cleanup after adding everything to ClearML + self.task.flush(wait_for_uploads=True) + self.temp_dir.cleanup() + self.temp_dir = tempfile.TemporaryDirectory() + self.reset_callback_meta() + + if finish: + self.task.close() diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/comet_ml_callback.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/comet_ml_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..6d682c9a05f898bb757b44cb75fcfe37500efb64 --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/comet_ml_callback.py @@ -0,0 +1,639 @@ +import tempfile +from copy import deepcopy +from pathlib import Path +from typing import Any, Callable, Dict, List, Optional, Sequence + +from langchain_core.agents import AgentAction, AgentFinish +from langchain_core.callbacks import BaseCallbackHandler +from langchain_core.outputs import Generation, LLMResult +from langchain_core.utils import guard_import + +import langchain_community +from langchain_community.callbacks.utils import ( + BaseMetadataCallbackHandler, + flatten_dict, + import_pandas, + import_spacy, + import_textstat, +) + +LANGCHAIN_MODEL_NAME = "langchain-model" + + +def import_comet_ml() -> Any: + """Import comet_ml and raise an error if it is not installed.""" + return guard_import("comet_ml") + + +def _get_experiment( + workspace: Optional[str] = None, project_name: Optional[str] = None +) -> Any: + comet_ml = import_comet_ml() + + experiment = comet_ml.Experiment( + workspace=workspace, + project_name=project_name, + ) + + return experiment + + +def _fetch_text_complexity_metrics(text: str) -> dict: + textstat = import_textstat() + text_complexity_metrics = { + "flesch_reading_ease": textstat.flesch_reading_ease(text), + "flesch_kincaid_grade": textstat.flesch_kincaid_grade(text), + "smog_index": textstat.smog_index(text), + "coleman_liau_index": textstat.coleman_liau_index(text), + "automated_readability_index": textstat.automated_readability_index(text), + "dale_chall_readability_score": textstat.dale_chall_readability_score(text), + "difficult_words": textstat.difficult_words(text), + "linsear_write_formula": textstat.linsear_write_formula(text), + "gunning_fog": textstat.gunning_fog(text), + "text_standard": textstat.text_standard(text), + "fernandez_huerta": textstat.fernandez_huerta(text), + "szigriszt_pazos": textstat.szigriszt_pazos(text), + "gutierrez_polini": textstat.gutierrez_polini(text), + "crawford": textstat.crawford(text), + "gulpease_index": textstat.gulpease_index(text), + "osman": textstat.osman(text), + } + return text_complexity_metrics + + +def _summarize_metrics_for_generated_outputs(metrics: Sequence) -> dict: + pd = import_pandas() + metrics_df = pd.DataFrame(metrics) + metrics_summary = metrics_df.describe() + + return metrics_summary.to_dict() + + +class CometCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler): + """Callback Handler that logs to Comet. + + Parameters: + job_type (str): The type of comet_ml task such as "inference", + "testing" or "qc" + project_name (str): The comet_ml project name + tags (list): Tags to add to the task + task_name (str): Name of the comet_ml task + visualize (bool): Whether to visualize the run. + complexity_metrics (bool): Whether to log complexity metrics + stream_logs (bool): Whether to stream callback actions to Comet + + This handler will utilize the associated callback method and formats + the input of each callback function with metadata regarding the state of LLM run, + and adds the response to the list of records for both the {method}_records and + action. It then logs the response to Comet. + """ + + def __init__( + self, + task_type: Optional[str] = "inference", + workspace: Optional[str] = None, + project_name: Optional[str] = None, + tags: Optional[Sequence] = None, + name: Optional[str] = None, + visualizations: Optional[List[str]] = None, + complexity_metrics: bool = False, + custom_metrics: Optional[Callable] = None, + stream_logs: bool = True, + ) -> None: + """Initialize callback handler.""" + + self.comet_ml = import_comet_ml() + super().__init__() + + self.task_type = task_type + self.workspace = workspace + self.project_name = project_name + self.tags = tags + self.visualizations = visualizations + self.complexity_metrics = complexity_metrics + self.custom_metrics = custom_metrics + self.stream_logs = stream_logs + self.temp_dir = tempfile.TemporaryDirectory() + + self.experiment = _get_experiment(workspace, project_name) + self.experiment.log_other("Created from", "langchain") + if tags: + self.experiment.add_tags(tags) + self.name = name + if self.name: + self.experiment.set_name(self.name) + + warning = ( + "The comet_ml callback is currently in beta and is subject to change " + "based on updates to `langchain`. Please report any issues to " + "https://github.com/comet-ml/issue-tracking/issues with the tag " + "`langchain`." + ) + self.comet_ml.LOGGER.warning(warning) + + self.callback_columns: list = [] + self.action_records: list = [] + self.complexity_metrics = complexity_metrics + if self.visualizations: + spacy = import_spacy() + self.nlp = spacy.load("en_core_web_sm") + else: + self.nlp = None + + def _init_resp(self) -> Dict: + return {k: None for k in self.callback_columns} + + def on_llm_start( + self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any + ) -> None: + """Run when LLM starts.""" + self.step += 1 + self.llm_starts += 1 + self.starts += 1 + + metadata = self._init_resp() + metadata.update({"action": "on_llm_start"}) + metadata.update(flatten_dict(serialized)) + metadata.update(self.get_custom_callback_meta()) + + for prompt in prompts: + prompt_resp = deepcopy(metadata) + prompt_resp["prompts"] = prompt + self.on_llm_start_records.append(prompt_resp) + self.action_records.append(prompt_resp) + + if self.stream_logs: + self._log_stream(prompt, metadata, self.step) + + def on_llm_new_token(self, token: str, **kwargs: Any) -> None: + """Run when LLM generates a new token.""" + self.step += 1 + self.llm_streams += 1 + + resp = self._init_resp() + resp.update({"action": "on_llm_new_token", "token": token}) + resp.update(self.get_custom_callback_meta()) + + self.action_records.append(resp) + + def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None: + """Run when LLM ends running.""" + self.step += 1 + self.llm_ends += 1 + self.ends += 1 + + metadata = self._init_resp() + metadata.update({"action": "on_llm_end"}) + metadata.update(flatten_dict(response.llm_output or {})) + metadata.update(self.get_custom_callback_meta()) + + output_complexity_metrics = [] + output_custom_metrics = [] + + for prompt_idx, generations in enumerate(response.generations): + for gen_idx, generation in enumerate(generations): + text = generation.text + + generation_resp = deepcopy(metadata) + generation_resp.update(flatten_dict(generation.dict())) + + complexity_metrics = self._get_complexity_metrics(text) + if complexity_metrics: + output_complexity_metrics.append(complexity_metrics) + generation_resp.update(complexity_metrics) + + custom_metrics = self._get_custom_metrics( + generation, prompt_idx, gen_idx + ) + if custom_metrics: + output_custom_metrics.append(custom_metrics) + generation_resp.update(custom_metrics) + + if self.stream_logs: + self._log_stream(text, metadata, self.step) + + self.action_records.append(generation_resp) + self.on_llm_end_records.append(generation_resp) + + self._log_text_metrics(output_complexity_metrics, step=self.step) + self._log_text_metrics(output_custom_metrics, step=self.step) + + def on_llm_error(self, error: BaseException, **kwargs: Any) -> None: + """Run when LLM errors.""" + self.step += 1 + self.errors += 1 + + def on_chain_start( + self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any + ) -> None: + """Run when chain starts running.""" + self.step += 1 + self.chain_starts += 1 + self.starts += 1 + + resp = self._init_resp() + resp.update({"action": "on_chain_start"}) + resp.update(flatten_dict(serialized)) + resp.update(self.get_custom_callback_meta()) + + for chain_input_key, chain_input_val in inputs.items(): + if isinstance(chain_input_val, str): + input_resp = deepcopy(resp) + if self.stream_logs: + self._log_stream(chain_input_val, resp, self.step) + input_resp.update({chain_input_key: chain_input_val}) + self.action_records.append(input_resp) + + else: + self.comet_ml.LOGGER.warning( + f"Unexpected data format provided! " + f"Input Value for {chain_input_key} will not be logged" + ) + + def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None: + """Run when chain ends running.""" + self.step += 1 + self.chain_ends += 1 + self.ends += 1 + + resp = self._init_resp() + resp.update({"action": "on_chain_end"}) + resp.update(self.get_custom_callback_meta()) + + for chain_output_key, chain_output_val in outputs.items(): + if isinstance(chain_output_val, str): + output_resp = deepcopy(resp) + if self.stream_logs: + self._log_stream(chain_output_val, resp, self.step) + output_resp.update({chain_output_key: chain_output_val}) + self.action_records.append(output_resp) + else: + self.comet_ml.LOGGER.warning( + f"Unexpected data format provided! " + f"Output Value for {chain_output_key} will not be logged" + ) + + def on_chain_error(self, error: BaseException, **kwargs: Any) -> None: + """Run when chain errors.""" + self.step += 1 + self.errors += 1 + + def on_tool_start( + self, serialized: Dict[str, Any], input_str: str, **kwargs: Any + ) -> None: + """Run when tool starts running.""" + self.step += 1 + self.tool_starts += 1 + self.starts += 1 + + resp = self._init_resp() + resp.update({"action": "on_tool_start"}) + resp.update(flatten_dict(serialized)) + resp.update(self.get_custom_callback_meta()) + if self.stream_logs: + self._log_stream(input_str, resp, self.step) + + resp.update({"input_str": input_str}) + self.action_records.append(resp) + + def on_tool_end(self, output: Any, **kwargs: Any) -> None: + """Run when tool ends running.""" + output = str(output) + self.step += 1 + self.tool_ends += 1 + self.ends += 1 + + resp = self._init_resp() + resp.update({"action": "on_tool_end"}) + resp.update(self.get_custom_callback_meta()) + if self.stream_logs: + self._log_stream(output, resp, self.step) + + resp.update({"output": output}) + self.action_records.append(resp) + + def on_tool_error(self, error: BaseException, **kwargs: Any) -> None: + """Run when tool errors.""" + self.step += 1 + self.errors += 1 + + def on_text(self, text: str, **kwargs: Any) -> None: + """ + Run when agent is ending. + """ + self.step += 1 + self.text_ctr += 1 + + resp = self._init_resp() + resp.update({"action": "on_text"}) + resp.update(self.get_custom_callback_meta()) + if self.stream_logs: + self._log_stream(text, resp, self.step) + + resp.update({"text": text}) + self.action_records.append(resp) + + def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None: + """Run when agent ends running.""" + self.step += 1 + self.agent_ends += 1 + self.ends += 1 + + resp = self._init_resp() + output = finish.return_values["output"] + log = finish.log + + resp.update({"action": "on_agent_finish", "log": log}) + resp.update(self.get_custom_callback_meta()) + if self.stream_logs: + self._log_stream(output, resp, self.step) + + resp.update({"output": output}) + self.action_records.append(resp) + + def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any: + """Run on agent action.""" + self.step += 1 + self.tool_starts += 1 + self.starts += 1 + + tool = action.tool + tool_input = str(action.tool_input) + log = action.log + + resp = self._init_resp() + resp.update({"action": "on_agent_action", "log": log, "tool": tool}) + resp.update(self.get_custom_callback_meta()) + if self.stream_logs: + self._log_stream(tool_input, resp, self.step) + + resp.update({"tool_input": tool_input}) + self.action_records.append(resp) + + def _get_complexity_metrics(self, text: str) -> dict: + """Compute text complexity metrics using textstat. + + Parameters: + text (str): The text to analyze. + + Returns: + `dict` containing the complexity metrics. + """ + resp = {} + if self.complexity_metrics: + text_complexity_metrics = _fetch_text_complexity_metrics(text) + resp.update(text_complexity_metrics) + + return resp + + def _get_custom_metrics( + self, generation: Generation, prompt_idx: int, gen_idx: int + ) -> dict: + """Compute Custom Metrics for an LLM Generated Output + + Args: + generation (LLMResult): Output generation from an LLM + prompt_idx (int): List index of the input prompt + gen_idx (int): List index of the generated output + + Returns: + dict: `dict` containing the custom metrics. + """ + + resp = {} + if self.custom_metrics: + custom_metrics = self.custom_metrics(generation, prompt_idx, gen_idx) + resp.update(custom_metrics) + + return resp + + def flush_tracker( + self, + langchain_asset: Any = None, + task_type: Optional[str] = "inference", + workspace: Optional[str] = None, + project_name: Optional[str] = "comet-langchain-demo", + tags: Optional[Sequence] = None, + name: Optional[str] = None, + visualizations: Optional[List[str]] = None, + complexity_metrics: bool = False, + custom_metrics: Optional[Callable] = None, + finish: bool = False, + reset: bool = False, + ) -> None: + """Flush the tracker and setup the session. + + Everything after this will be a new table. + + Args: + name: Name of the performed session so far so it is identifiable + langchain_asset: The langchain asset to save. + finish: Whether to finish the run. + + Returns: + None + """ + self._log_session(langchain_asset) + + if langchain_asset: + try: + self._log_model(langchain_asset) + except Exception: + self.comet_ml.LOGGER.error( + "Failed to export agent or LLM to Comet", + exc_info=True, + extra={"show_traceback": True}, + ) + + if finish: + self.experiment.end() + + if reset: + self._reset( + task_type, + workspace, + project_name, + tags, + name, + visualizations, + complexity_metrics, + custom_metrics, + ) + + def _log_stream(self, prompt: str, metadata: dict, step: int) -> None: + self.experiment.log_text(prompt, metadata=metadata, step=step) + + def _log_model(self, langchain_asset: Any) -> None: + model_parameters = self._get_llm_parameters(langchain_asset) + self.experiment.log_parameters(model_parameters, prefix="model") + + langchain_asset_path = Path(self.temp_dir.name, "model.json") + model_name = self.name if self.name else LANGCHAIN_MODEL_NAME + + try: + if hasattr(langchain_asset, "save"): + langchain_asset.save(langchain_asset_path) + self.experiment.log_model(model_name, str(langchain_asset_path)) + except (ValueError, AttributeError, NotImplementedError) as e: + if hasattr(langchain_asset, "save_agent"): + langchain_asset.save_agent(langchain_asset_path) + self.experiment.log_model(model_name, str(langchain_asset_path)) + else: + self.comet_ml.LOGGER.error( + f"{e}" + " Could not save Langchain Asset " + f"for {langchain_asset.__class__.__name__}" + ) + + def _log_session(self, langchain_asset: Optional[Any] = None) -> None: + try: + llm_session_df = self._create_session_analysis_dataframe(langchain_asset) + # Log the cleaned dataframe as a table + self.experiment.log_table("langchain-llm-session.csv", llm_session_df) + except Exception: + self.comet_ml.LOGGER.warning( + "Failed to log session data to Comet", + exc_info=True, + extra={"show_traceback": True}, + ) + + try: + metadata = {"langchain_version": str(langchain_community.__version__)} + # Log the langchain low-level records as a JSON file directly + self.experiment.log_asset_data( + self.action_records, "langchain-action_records.json", metadata=metadata + ) + except Exception: + self.comet_ml.LOGGER.warning( + "Failed to log session data to Comet", + exc_info=True, + extra={"show_traceback": True}, + ) + + try: + self._log_visualizations(llm_session_df) + except Exception: + self.comet_ml.LOGGER.warning( + "Failed to log visualizations to Comet", + exc_info=True, + extra={"show_traceback": True}, + ) + + def _log_text_metrics(self, metrics: Sequence[dict], step: int) -> None: + if not metrics: + return + + metrics_summary = _summarize_metrics_for_generated_outputs(metrics) + for key, value in metrics_summary.items(): + self.experiment.log_metrics(value, prefix=key, step=step) + + def _log_visualizations(self, session_df: Any) -> None: + if not (self.visualizations and self.nlp): + return + + spacy = import_spacy() + + prompts = session_df["prompts"].tolist() + outputs = session_df["text"].tolist() + + for idx, (prompt, output) in enumerate(zip(prompts, outputs)): + doc = self.nlp(output) + sentence_spans = list(doc.sents) + + for visualization in self.visualizations: + try: + html = spacy.displacy.render( + sentence_spans, + style=visualization, + options={"compact": True}, + jupyter=False, + page=True, + ) + self.experiment.log_asset_data( + html, + name=f"langchain-viz-{visualization}-{idx}.html", + metadata={"prompt": prompt}, + step=idx, + ) + except Exception as e: + self.comet_ml.LOGGER.warning( + e, exc_info=True, extra={"show_traceback": True} + ) + + return + + def _reset( + self, + task_type: Optional[str] = None, + workspace: Optional[str] = None, + project_name: Optional[str] = None, + tags: Optional[Sequence] = None, + name: Optional[str] = None, + visualizations: Optional[List[str]] = None, + complexity_metrics: bool = False, + custom_metrics: Optional[Callable] = None, + ) -> None: + _task_type = task_type if task_type else self.task_type + _workspace = workspace if workspace else self.workspace + _project_name = project_name if project_name else self.project_name + _tags = tags if tags else self.tags + _name = name if name else self.name + _visualizations = visualizations if visualizations else self.visualizations + _complexity_metrics = ( + complexity_metrics if complexity_metrics else self.complexity_metrics + ) + _custom_metrics = custom_metrics if custom_metrics else self.custom_metrics + + self.__init__( # type: ignore[misc] + task_type=_task_type, + workspace=_workspace, + project_name=_project_name, + tags=_tags, + name=_name, + visualizations=_visualizations, + complexity_metrics=_complexity_metrics, + custom_metrics=_custom_metrics, + ) + + self.reset_callback_meta() + self.temp_dir = tempfile.TemporaryDirectory() + + def _create_session_analysis_dataframe(self, langchain_asset: Any = None) -> dict: + pd = import_pandas() + + llm_parameters = self._get_llm_parameters(langchain_asset) + num_generations_per_prompt = llm_parameters.get("n", 1) + + llm_start_records_df = pd.DataFrame(self.on_llm_start_records) + # Repeat each input row based on the number of outputs generated per prompt + llm_start_records_df = llm_start_records_df.loc[ + llm_start_records_df.index.repeat(num_generations_per_prompt) + ].reset_index(drop=True) + llm_end_records_df = pd.DataFrame(self.on_llm_end_records) + + llm_session_df = pd.merge( + llm_start_records_df, + llm_end_records_df, + left_index=True, + right_index=True, + suffixes=["_llm_start", "_llm_end"], + ) + + return llm_session_df + + def _get_llm_parameters(self, langchain_asset: Any = None) -> dict: + if not langchain_asset: + return {} + try: + if hasattr(langchain_asset, "agent"): + llm_parameters = langchain_asset.agent.llm_chain.llm.dict() + elif hasattr(langchain_asset, "llm_chain"): + llm_parameters = langchain_asset.llm_chain.llm.dict() + elif hasattr(langchain_asset, "llm"): + llm_parameters = langchain_asset.llm.dict() + else: + llm_parameters = langchain_asset.dict() + except Exception: + return {} + + return llm_parameters diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/confident_callback.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/confident_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..b078abf45074c3912625389d374ae325fa0c68d0 --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/confident_callback.py @@ -0,0 +1,183 @@ +# flake8: noqa +import os +import warnings +from typing import Any, Dict, List, Optional, Union + +from langchain_core.callbacks import BaseCallbackHandler +from langchain_core.agents import AgentAction, AgentFinish +from langchain_core.outputs import LLMResult + + +class DeepEvalCallbackHandler(BaseCallbackHandler): + """Callback Handler that logs into deepeval. + + Args: + implementation_name: name of the `implementation` in deepeval + metrics: A list of metrics + + Raises: + ImportError: if the `deepeval` package is not installed. + + Examples: + >>> from langchain_community.llms import OpenAI + >>> from langchain_community.callbacks import DeepEvalCallbackHandler + >>> from deepeval.metrics import AnswerRelevancy + >>> metric = AnswerRelevancy(minimum_score=0.3) + >>> deepeval_callback = DeepEvalCallbackHandler( + ... implementation_name="exampleImplementation", + ... metrics=[metric], + ... ) + >>> llm = OpenAI( + ... temperature=0, + ... callbacks=[deepeval_callback], + ... verbose=True, + ... openai_api_key="API_KEY_HERE", + ... ) + >>> llm.generate([ + ... "What is the best evaluation tool out there? (no bias at all)", + ... ]) + "Deepeval, no doubt about it." + """ + + REPO_URL: str = "https://github.com/confident-ai/deepeval" + ISSUES_URL: str = f"{REPO_URL}/issues" + BLOG_URL: str = "https://docs.confident-ai.com" # noqa: E501 + + def __init__( + self, + metrics: List[Any], + implementation_name: Optional[str] = None, + ) -> None: + """Initializes the `deepevalCallbackHandler`. + + Args: + implementation_name: Name of the implementation you want. + metrics: What metrics do you want to track? + + Raises: + ImportError: if the `deepeval` package is not installed. + ConnectionError: if the connection to deepeval fails. + """ + + super().__init__() + + # Import deepeval (not via `import_deepeval` to keep hints in IDEs) + try: + import deepeval # ignore: F401,I001 + except ImportError: + raise ImportError( + """To use the deepeval callback manager you need to have the + `deepeval` Python package installed. Please install it with + `pip install deepeval`""" + ) + + if os.path.exists(".deepeval"): + warnings.warn( + """You are currently not logging anything to the dashboard, we + recommend using `deepeval login`.""" + ) + + # Set the deepeval variables + self.implementation_name = implementation_name + self.metrics = metrics + + warnings.warn( + ( + "The `DeepEvalCallbackHandler` is currently in beta and is subject to" + " change based on updates to `langchain`. Please report any issues to" + f" {self.ISSUES_URL} as an `integration` issue." + ), + ) + + def on_llm_start( + self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any + ) -> None: + """Store the prompts""" + self.prompts = prompts + + def on_llm_new_token(self, token: str, **kwargs: Any) -> None: + """Do nothing when a new token is generated.""" + pass + + def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None: + """Log records to deepeval when an LLM ends.""" + from deepeval.metrics.answer_relevancy import AnswerRelevancy + from deepeval.metrics.bias_classifier import UnBiasedMetric + from deepeval.metrics.metric import Metric + from deepeval.metrics.toxic_classifier import NonToxicMetric + + for metric in self.metrics: + for i, generation in enumerate(response.generations): + # Here, we only measure the first generation's output + output = generation[0].text + query = self.prompts[i] + if isinstance(metric, AnswerRelevancy): + result = metric.measure( + output=output, + query=query, + ) + print(f"Answer Relevancy: {result}") # noqa: T201 + elif isinstance(metric, UnBiasedMetric): + score = metric.measure(output) + print(f"Bias Score: {score}") # noqa: T201 + elif isinstance(metric, NonToxicMetric): + score = metric.measure(output) + print(f"Toxic Score: {score}") # noqa: T201 + else: + raise ValueError( + f"""Metric {metric.__name__} is not supported by deepeval + callbacks.""" + ) + + def on_llm_error(self, error: BaseException, **kwargs: Any) -> None: + """Do nothing when LLM outputs an error.""" + pass + + def on_chain_start( + self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any + ) -> None: + """Do nothing when chain starts""" + pass + + def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None: + """Do nothing when chain ends.""" + pass + + def on_chain_error(self, error: BaseException, **kwargs: Any) -> None: + """Do nothing when LLM chain outputs an error.""" + pass + + def on_tool_start( + self, + serialized: Dict[str, Any], + input_str: str, + **kwargs: Any, + ) -> None: + """Do nothing when tool starts.""" + pass + + def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any: + """Do nothing when agent takes a specific action.""" + pass + + def on_tool_end( + self, + output: Any, + observation_prefix: Optional[str] = None, + llm_prefix: Optional[str] = None, + **kwargs: Any, + ) -> None: + """Do nothing when tool ends.""" + pass + + def on_tool_error(self, error: BaseException, **kwargs: Any) -> None: + """Do nothing when tool outputs an error.""" + pass + + def on_text(self, text: str, **kwargs: Any) -> None: + """Do nothing""" + pass + + def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None: + """Do nothing""" + pass diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/context_callback.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/context_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d2b6d1e3e26511a784b8c30f8dafd52e8b9a2 --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/context_callback.py @@ -0,0 +1,192 @@ +"""Callback handler for Context AI""" + +import os +from typing import Any, Dict, List +from uuid import UUID + +from langchain_core.callbacks import BaseCallbackHandler +from langchain_core.messages import BaseMessage +from langchain_core.outputs import LLMResult +from langchain_core.utils import guard_import + + +def import_context() -> Any: + """Import the `getcontext` package.""" + return ( + guard_import("getcontext", pip_name="python-context"), + guard_import("getcontext.token", pip_name="python-context").Credential, + guard_import( + "getcontext.generated.models", pip_name="python-context" + ).Conversation, + guard_import("getcontext.generated.models", pip_name="python-context").Message, + guard_import( + "getcontext.generated.models", pip_name="python-context" + ).MessageRole, + guard_import("getcontext.generated.models", pip_name="python-context").Rating, + ) + + +class ContextCallbackHandler(BaseCallbackHandler): + """Callback Handler that records transcripts to the Context service. + + (https://context.ai). + + Keyword Args: + token (optional): The token with which to authenticate requests to Context. + Visit https://with.context.ai/settings to generate a token. + If not provided, the value of the `CONTEXT_TOKEN` environment + variable will be used. + + Raises: + ImportError: if the `context-python` package is not installed. + + Chat Example: + >>> from langchain_community.llms import ChatOpenAI + >>> from langchain_community.callbacks import ContextCallbackHandler + >>> context_callback = ContextCallbackHandler( + ... token="", + ... ) + >>> chat = ChatOpenAI( + ... temperature=0, + ... headers={"user_id": "123"}, + ... callbacks=[context_callback], + ... openai_api_key="API_KEY_HERE", + ... ) + >>> messages = [ + ... SystemMessage(content="You translate English to French."), + ... HumanMessage(content="I love programming with LangChain."), + ... ] + >>> chat.invoke(messages) + + Chain Example: + >>> from langchain_classic.chains import LLMChain + >>> from langchain_community.chat_models import ChatOpenAI + >>> from langchain_community.callbacks import ContextCallbackHandler + >>> context_callback = ContextCallbackHandler( + ... token="", + ... ) + >>> human_message_prompt = HumanMessagePromptTemplate( + ... prompt=PromptTemplate( + ... template="What is a good name for a company that makes {product}?", + ... input_variables=["product"], + ... ), + ... ) + >>> chat_prompt_template = ChatPromptTemplate.from_messages( + ... [human_message_prompt] + ... ) + >>> callback = ContextCallbackHandler(token) + >>> # Note: the same callback object must be shared between the + ... LLM and the chain. + >>> chat = ChatOpenAI(temperature=0.9, callbacks=[callback]) + >>> chain = LLMChain( + ... llm=chat, + ... prompt=chat_prompt_template, + ... callbacks=[callback] + ... ) + >>> chain.run("colorful socks") + """ + + def __init__(self, token: str = "", verbose: bool = False, **kwargs: Any) -> None: + ( + self.context, + self.credential, + self.conversation_model, + self.message_model, + self.message_role_model, + self.rating_model, + ) = import_context() + + token = token or os.environ.get("CONTEXT_TOKEN") or "" + + self.client = self.context.ContextAPI(credential=self.credential(token)) + + self.chain_run_id = None + + self.llm_model = None + + self.messages: List[Any] = [] + self.metadata: Dict[str, str] = {} + + def on_chat_model_start( + self, + serialized: Dict[str, Any], + messages: List[List[BaseMessage]], + *, + run_id: UUID, + **kwargs: Any, + ) -> Any: + """Run when the chat model is started.""" + llm_model = kwargs.get("invocation_params", {}).get("model", None) + if llm_model is not None: + self.metadata["model"] = llm_model + + if len(messages) == 0: + return + + for message in messages[0]: + role = self.message_role_model.SYSTEM + if message.type == "human": + role = self.message_role_model.USER + elif message.type == "system": + role = self.message_role_model.SYSTEM + elif message.type == "ai": + role = self.message_role_model.ASSISTANT + + self.messages.append( + self.message_model( + message=message.content, + role=role, + ) + ) + + def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None: + """Run when LLM ends.""" + if len(response.generations) == 0 or len(response.generations[0]) == 0: + return + + if not self.chain_run_id: + generation = response.generations[0][0] + self.messages.append( + self.message_model( + message=generation.text, + role=self.message_role_model.ASSISTANT, + ) + ) + + self._log_conversation() + + def on_chain_start( + self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any + ) -> None: + """Run when chain starts.""" + self.chain_run_id = kwargs.get("run_id", None) + + def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None: + """Run when chain ends.""" + self.messages.append( + self.message_model( + message=outputs["text"], + role=self.message_role_model.ASSISTANT, + ) + ) + + self._log_conversation() + + self.chain_run_id = None + + def _log_conversation(self) -> None: + """Log the conversation to the context API.""" + if len(self.messages) == 0: + return + + self.client.log.conversation_upsert( + body={ + "conversation": self.conversation_model( + messages=self.messages, + metadata=self.metadata, + ) + } + ) + + self.messages = [] + self.metadata = {} diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/fiddler_callback.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/fiddler_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..0ff6ed894d0b659573490c13a9ebbc3eecb675ff --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/fiddler_callback.py @@ -0,0 +1,335 @@ +import time +from typing import Any, Dict, List, Optional +from uuid import UUID + +from langchain_core.callbacks import BaseCallbackHandler +from langchain_core.outputs import LLMResult +from langchain_core.utils import guard_import + +from langchain_community.callbacks.utils import import_pandas + +# Define constants + +# LLMResult keys +TOKEN_USAGE = "token_usage" +TOTAL_TOKENS = "total_tokens" +PROMPT_TOKENS = "prompt_tokens" +COMPLETION_TOKENS = "completion_tokens" +RUN_ID = "run_id" +MODEL_NAME = "model_name" +GOOD = "good" +BAD = "bad" +NEUTRAL = "neutral" +SUCCESS = "success" +FAILURE = "failure" + +# Default values +DEFAULT_MAX_TOKEN = 65536 +DEFAULT_MAX_DURATION = 120000 + +# Fiddler specific constants +PROMPT = "prompt" +RESPONSE = "response" +CONTEXT = "context" +DURATION = "duration" +FEEDBACK = "feedback" +LLM_STATUS = "llm_status" + +FEEDBACK_POSSIBLE_VALUES = [GOOD, BAD, NEUTRAL] + +# Define a dataset dictionary +_dataset_dict = { + PROMPT: ["fiddler"] * 10, + RESPONSE: ["fiddler"] * 10, + CONTEXT: ["fiddler"] * 10, + FEEDBACK: ["good"] * 10, + LLM_STATUS: ["success"] * 10, + MODEL_NAME: ["fiddler"] * 10, + RUN_ID: ["123e4567-e89b-12d3-a456-426614174000"] * 10, + TOTAL_TOKENS: [0, DEFAULT_MAX_TOKEN] * 5, + PROMPT_TOKENS: [0, DEFAULT_MAX_TOKEN] * 5, + COMPLETION_TOKENS: [0, DEFAULT_MAX_TOKEN] * 5, + DURATION: [1, DEFAULT_MAX_DURATION] * 5, +} + + +def import_fiddler() -> Any: + """Import the fiddler python package and raise an error if it is not installed.""" + return guard_import("fiddler", pip_name="fiddler-client") + + +# First, define custom callback handler implementations +class FiddlerCallbackHandler(BaseCallbackHandler): + def __init__( + self, + url: str, + org: str, + project: str, + model: str, + api_key: str, + ) -> None: + """ + Initialize Fiddler callback handler. + + Args: + url: Fiddler URL (e.g. https://demo.fiddler.ai). + Make sure to include the protocol (http/https). + org: Fiddler organization id + project: Fiddler project name to publish events to + model: Fiddler model name to publish events to + api_key: Fiddler authentication token + """ + super().__init__() + # Initialize Fiddler client and other necessary properties + self.fdl = import_fiddler() + self.pd = import_pandas() + + self.url = url + self.org = org + self.project = project + self.model = model + self.api_key = api_key + self._df = self.pd.DataFrame(_dataset_dict) + + self.run_id_prompts: Dict[UUID, List[str]] = {} + self.run_id_response: Dict[UUID, List[str]] = {} + self.run_id_starttime: Dict[UUID, int] = {} + + # Initialize Fiddler client here + self.fiddler_client = self.fdl.FiddlerApi(url, org_id=org, auth_token=api_key) + + if self.project not in self.fiddler_client.get_project_names(): + print( # noqa: T201 + f"adding project {self.project}.This only has to be done once." + ) + try: + self.fiddler_client.add_project(self.project) + except Exception as e: + print( # noqa: T201 + f"Error adding project {self.project}:" + "{e}. Fiddler integration will not work." + ) + raise e + + dataset_info = self.fdl.DatasetInfo.from_dataframe( + self._df, max_inferred_cardinality=0 + ) + + # Set feedback column to categorical + for i in range(len(dataset_info.columns)): + if dataset_info.columns[i].name == FEEDBACK: + dataset_info.columns[i].data_type = self.fdl.DataType.CATEGORY + dataset_info.columns[i].possible_values = FEEDBACK_POSSIBLE_VALUES + + elif dataset_info.columns[i].name == LLM_STATUS: + dataset_info.columns[i].data_type = self.fdl.DataType.CATEGORY + dataset_info.columns[i].possible_values = [SUCCESS, FAILURE] + + if self.model not in self.fiddler_client.get_model_names(self.project): + if self.model not in self.fiddler_client.get_dataset_names(self.project): + print( # noqa: T201 + f"adding dataset {self.model} to project {self.project}." + "This only has to be done once." + ) + try: + self.fiddler_client.upload_dataset( + project_id=self.project, + dataset_id=self.model, + dataset={"train": self._df}, + info=dataset_info, + ) + except Exception as e: + print( # noqa: T201 + f"Error adding dataset {self.model}: {e}." + "Fiddler integration will not work." + ) + raise e + + model_info = self.fdl.ModelInfo.from_dataset_info( + dataset_info=dataset_info, + dataset_id="train", + model_task=self.fdl.ModelTask.LLM, + features=[PROMPT, CONTEXT, RESPONSE], + target=FEEDBACK, + metadata_cols=[ + RUN_ID, + TOTAL_TOKENS, + PROMPT_TOKENS, + COMPLETION_TOKENS, + MODEL_NAME, + DURATION, + ], + custom_features=self.custom_features, + ) + print( # noqa: T201 + f"adding model {self.model} to project {self.project}." + "This only has to be done once." + ) + try: + self.fiddler_client.add_model( + project_id=self.project, + dataset_id=self.model, + model_id=self.model, + model_info=model_info, + ) + except Exception as e: + print( # noqa: T201 + f"Error adding model {self.model}: {e}." + "Fiddler integration will not work." + ) + raise e + + @property + def custom_features(self) -> list: + """ + Define custom features for the model to automatically enrich the data with. + Here, we enable the following enrichments: + - Automatic Embedding generation for prompt and response + - Text Statistics such as: + - Automated Readability Index + - Coleman Liau Index + - Dale Chall Readability Score + - Difficult Words + - Flesch Reading Ease + - Flesch Kincaid Grade + - Gunning Fog + - Linsear Write Formula + - PII - Personal Identifiable Information + - Sentiment Analysis + + """ + + return [ + self.fdl.Enrichment( + name="Prompt Embedding", + enrichment="embedding", + columns=[PROMPT], + ), + self.fdl.TextEmbedding( + name="Prompt CF", + source_column=PROMPT, + column="Prompt Embedding", + ), + self.fdl.Enrichment( + name="Response Embedding", + enrichment="embedding", + columns=[RESPONSE], + ), + self.fdl.TextEmbedding( + name="Response CF", + source_column=RESPONSE, + column="Response Embedding", + ), + self.fdl.Enrichment( + name="Text Statistics", + enrichment="textstat", + columns=[PROMPT, RESPONSE], + config={ + "statistics": [ + "automated_readability_index", + "coleman_liau_index", + "dale_chall_readability_score", + "difficult_words", + "flesch_reading_ease", + "flesch_kincaid_grade", + "gunning_fog", + "linsear_write_formula", + ] + }, + ), + self.fdl.Enrichment( + name="PII", + enrichment="pii", + columns=[PROMPT, RESPONSE], + ), + self.fdl.Enrichment( + name="Sentiment", + enrichment="sentiment", + columns=[PROMPT, RESPONSE], + ), + ] + + def _publish_events( + self, + run_id: UUID, + prompt_responses: List[str], + duration: int, + llm_status: str, + model_name: Optional[str] = "", + token_usage_dict: Optional[Dict[str, Any]] = None, + ) -> None: + """ + Publish events to fiddler + """ + + prompt_count = len(self.run_id_prompts[run_id]) + df = self.pd.DataFrame( + { + PROMPT: self.run_id_prompts[run_id], + RESPONSE: prompt_responses, + RUN_ID: [str(run_id)] * prompt_count, + DURATION: [duration] * prompt_count, + LLM_STATUS: [llm_status] * prompt_count, + MODEL_NAME: [model_name] * prompt_count, + } + ) + + if token_usage_dict: + for key, value in token_usage_dict.items(): + df[key] = [value] * prompt_count if isinstance(value, int) else value + + try: + if df.shape[0] > 1: + self.fiddler_client.publish_events_batch(self.project, self.model, df) + else: + df_dict = df.to_dict(orient="records") + self.fiddler_client.publish_event( + self.project, self.model, event=df_dict[0] + ) + except Exception as e: + print( # noqa: T201 + f"Error publishing events to fiddler: {e}. continuing..." + ) + + def on_llm_start( + self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any + ) -> Any: + run_id = kwargs[RUN_ID] + self.run_id_prompts[run_id] = prompts + self.run_id_starttime[run_id] = int(time.time() * 1000) + + def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None: + flattened_llmresult = response.flatten() + run_id = kwargs[RUN_ID] + run_duration = int(time.time() * 1000) - self.run_id_starttime[run_id] + model_name = "" + token_usage_dict = {} + + if isinstance(response.llm_output, dict): + token_usage_dict = { + k: v + for k, v in response.llm_output.items() + if k in [TOTAL_TOKENS, PROMPT_TOKENS, COMPLETION_TOKENS] + } + model_name = response.llm_output.get(MODEL_NAME, "") + + prompt_responses = [ + llmresult.generations[0][0].text for llmresult in flattened_llmresult + ] + + self._publish_events( + run_id, + prompt_responses, + run_duration, + SUCCESS, + model_name, + token_usage_dict, + ) + + def on_llm_error(self, error: BaseException, **kwargs: Any) -> None: + run_id = kwargs[RUN_ID] + duration = int(time.time() * 1000) - self.run_id_starttime[run_id] + + self._publish_events( + run_id, [""] * len(self.run_id_prompts[run_id]), duration, FAILURE + ) diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/flyte_callback.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/flyte_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..e108d13cbeeb62b3ac64098cd347860d01e20924 --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/flyte_callback.py @@ -0,0 +1,364 @@ +"""FlyteKit callback handler.""" + +from __future__ import annotations + +import logging +from copy import deepcopy +from typing import TYPE_CHECKING, Any, Dict, List, Tuple + +from langchain_core.agents import AgentAction, AgentFinish +from langchain_core.callbacks import BaseCallbackHandler +from langchain_core.outputs import LLMResult +from langchain_core.utils import guard_import + +from langchain_community.callbacks.utils import ( + BaseMetadataCallbackHandler, + flatten_dict, + import_pandas, + import_spacy, + import_textstat, +) + +if TYPE_CHECKING: + import flytekit + from flytekitplugins.deck import renderer + +logger = logging.getLogger(__name__) + + +def import_flytekit() -> Tuple[flytekit, renderer]: + """Import flytekit and flytekitplugins-deck-standard.""" + return ( + guard_import("flytekit"), + guard_import( + "flytekitplugins.deck", pip_name="flytekitplugins-deck-standard" + ).renderer, + ) + + +def analyze_text( + text: str, + nlp: Any = None, + textstat: Any = None, +) -> dict: + """Analyze text using textstat and spacy. + + Parameters: + text (str): The text to analyze. + nlp (spacy.lang): The spacy language model to use for visualization. + + Returns: + `dict` containing the complexity metrics and visualization + files serialized to HTML string. + """ + resp: Dict[str, Any] = {} + if textstat is not None: + text_complexity_metrics = { + "flesch_reading_ease": textstat.flesch_reading_ease(text), + "flesch_kincaid_grade": textstat.flesch_kincaid_grade(text), + "smog_index": textstat.smog_index(text), + "coleman_liau_index": textstat.coleman_liau_index(text), + "automated_readability_index": textstat.automated_readability_index(text), + "dale_chall_readability_score": textstat.dale_chall_readability_score(text), + "difficult_words": textstat.difficult_words(text), + "linsear_write_formula": textstat.linsear_write_formula(text), + "gunning_fog": textstat.gunning_fog(text), + "fernandez_huerta": textstat.fernandez_huerta(text), + "szigriszt_pazos": textstat.szigriszt_pazos(text), + "gutierrez_polini": textstat.gutierrez_polini(text), + "crawford": textstat.crawford(text), + "gulpease_index": textstat.gulpease_index(text), + "osman": textstat.osman(text), + } + resp.update({"text_complexity_metrics": text_complexity_metrics}) + resp.update(text_complexity_metrics) + + if nlp is not None: + spacy = import_spacy() + doc = nlp(text) + dep_out = spacy.displacy.render(doc, style="dep", jupyter=False, page=True) + ent_out = spacy.displacy.render(doc, style="ent", jupyter=False, page=True) + text_visualizations = { + "dependency_tree": dep_out, + "entities": ent_out, + } + resp.update(text_visualizations) + + return resp + + +class FlyteCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler): + """Callback handler that is used within a Flyte task.""" + + def __init__(self) -> None: + """Initialize callback handler.""" + flytekit, renderer = import_flytekit() + self.pandas = import_pandas() + + self.textstat = None + try: + self.textstat = import_textstat() + except ImportError: + logger.warning( + "Textstat library is not installed. \ + It may result in the inability to log \ + certain metrics that can be captured with Textstat." + ) + + spacy = None + try: + spacy = import_spacy() + except ImportError: + logger.warning( + "Spacy library is not installed. \ + It may result in the inability to log \ + certain metrics that can be captured with Spacy." + ) + + super().__init__() + + self.nlp = None + if spacy: + try: + self.nlp = spacy.load("en_core_web_sm") + except OSError: + logger.warning( + "FlyteCallbackHandler uses spacy's en_core_web_sm model" + " for certain metrics. To download," + " run the following command in your terminal:" + " `python -m spacy download en_core_web_sm`" + ) + + self.table_renderer = renderer.TableRenderer + self.markdown_renderer = renderer.MarkdownRenderer + + self.deck = flytekit.Deck( + "LangChain Metrics", + self.markdown_renderer().to_html("## LangChain Metrics"), + ) + + def on_llm_start( + self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any + ) -> None: + """Run when LLM starts.""" + + self.step += 1 + self.llm_starts += 1 + self.starts += 1 + + resp: Dict[str, Any] = {} + resp.update({"action": "on_llm_start"}) + resp.update(flatten_dict(serialized)) + resp.update(self.get_custom_callback_meta()) + + prompt_responses = [] + for prompt in prompts: + prompt_responses.append(prompt) + + resp.update({"prompts": prompt_responses}) + + self.deck.append(self.markdown_renderer().to_html("### LLM Start")) + self.deck.append( + self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n" + ) + + def on_llm_new_token(self, token: str, **kwargs: Any) -> None: + """Run when LLM generates a new token.""" + + def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None: + """Run when LLM ends running.""" + self.step += 1 + self.llm_ends += 1 + self.ends += 1 + + resp: Dict[str, Any] = {} + resp.update({"action": "on_llm_end"}) + resp.update(flatten_dict(response.llm_output or {})) + resp.update(self.get_custom_callback_meta()) + + self.deck.append(self.markdown_renderer().to_html("### LLM End")) + self.deck.append(self.table_renderer().to_html(self.pandas.DataFrame([resp]))) + + for generations in response.generations: + for generation in generations: + generation_resp = deepcopy(resp) + generation_resp.update(flatten_dict(generation.dict())) + if self.nlp or self.textstat: + generation_resp.update( + analyze_text( + generation.text, nlp=self.nlp, textstat=self.textstat + ) + ) + + complexity_metrics: Dict[str, float] = generation_resp.pop( + "text_complexity_metrics" + ) + self.deck.append( + self.markdown_renderer().to_html("#### Text Complexity Metrics") + ) + self.deck.append( + self.table_renderer().to_html( + self.pandas.DataFrame([complexity_metrics]) + ) + + "\n" + ) + + dependency_tree = generation_resp["dependency_tree"] + self.deck.append( + self.markdown_renderer().to_html("#### Dependency Tree") + ) + self.deck.append(dependency_tree) + + entities = generation_resp["entities"] + self.deck.append(self.markdown_renderer().to_html("#### Entities")) + self.deck.append(entities) + else: + self.deck.append( + self.markdown_renderer().to_html("#### Generated Response") + ) + self.deck.append(self.markdown_renderer().to_html(generation.text)) + + def on_llm_error(self, error: BaseException, **kwargs: Any) -> None: + """Run when LLM errors.""" + self.step += 1 + self.errors += 1 + + def on_chain_start( + self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any + ) -> None: + """Run when chain starts running.""" + self.step += 1 + self.chain_starts += 1 + self.starts += 1 + + resp: Dict[str, Any] = {} + resp.update({"action": "on_chain_start"}) + resp.update(flatten_dict(serialized)) + resp.update(self.get_custom_callback_meta()) + + chain_input = ",".join([f"{k}={v}" for k, v in inputs.items()]) + input_resp = deepcopy(resp) + input_resp["inputs"] = chain_input + + self.deck.append(self.markdown_renderer().to_html("### Chain Start")) + self.deck.append( + self.table_renderer().to_html(self.pandas.DataFrame([input_resp])) + "\n" + ) + + def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None: + """Run when chain ends running.""" + self.step += 1 + self.chain_ends += 1 + self.ends += 1 + + resp: Dict[str, Any] = {} + chain_output = ",".join([f"{k}={v}" for k, v in outputs.items()]) + resp.update({"action": "on_chain_end", "outputs": chain_output}) + resp.update(self.get_custom_callback_meta()) + + self.deck.append(self.markdown_renderer().to_html("### Chain End")) + self.deck.append( + self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n" + ) + + def on_chain_error(self, error: BaseException, **kwargs: Any) -> None: + """Run when chain errors.""" + self.step += 1 + self.errors += 1 + + def on_tool_start( + self, serialized: Dict[str, Any], input_str: str, **kwargs: Any + ) -> None: + """Run when tool starts running.""" + self.step += 1 + self.tool_starts += 1 + self.starts += 1 + + resp: Dict[str, Any] = {} + resp.update({"action": "on_tool_start", "input_str": input_str}) + resp.update(flatten_dict(serialized)) + resp.update(self.get_custom_callback_meta()) + + self.deck.append(self.markdown_renderer().to_html("### Tool Start")) + self.deck.append( + self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n" + ) + + def on_tool_end(self, output: str, **kwargs: Any) -> None: + """Run when tool ends running.""" + self.step += 1 + self.tool_ends += 1 + self.ends += 1 + + resp: Dict[str, Any] = {} + resp.update({"action": "on_tool_end", "output": output}) + resp.update(self.get_custom_callback_meta()) + + self.deck.append(self.markdown_renderer().to_html("### Tool End")) + self.deck.append( + self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n" + ) + + def on_tool_error(self, error: BaseException, **kwargs: Any) -> None: + """Run when tool errors.""" + self.step += 1 + self.errors += 1 + + def on_text(self, text: str, **kwargs: Any) -> None: + """ + Run when agent is ending. + """ + self.step += 1 + self.text_ctr += 1 + + resp: Dict[str, Any] = {} + resp.update({"action": "on_text", "text": text}) + resp.update(self.get_custom_callback_meta()) + + self.deck.append(self.markdown_renderer().to_html("### On Text")) + self.deck.append( + self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n" + ) + + def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None: + """Run when agent ends running.""" + self.step += 1 + self.agent_ends += 1 + self.ends += 1 + + resp: Dict[str, Any] = {} + resp.update( + { + "action": "on_agent_finish", + "output": finish.return_values["output"], + "log": finish.log, + } + ) + resp.update(self.get_custom_callback_meta()) + + self.deck.append(self.markdown_renderer().to_html("### Agent Finish")) + self.deck.append( + self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n" + ) + + def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any: + """Run on agent action.""" + self.step += 1 + self.tool_starts += 1 + self.starts += 1 + + resp: Dict[str, Any] = {} + resp.update( + { + "action": "on_agent_action", + "tool": action.tool, + "tool_input": action.tool_input, + "log": action.log, + } + ) + resp.update(self.get_custom_callback_meta()) + + self.deck.append(self.markdown_renderer().to_html("### Agent Action")) + self.deck.append( + self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n" + ) diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/human.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/human.py new file mode 100644 index 0000000000000000000000000000000000000000..64ea01f99f524fca14ffbabb6bc2560341a10415 --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/human.py @@ -0,0 +1,88 @@ +from typing import Any, Awaitable, Callable, Dict, Optional +from uuid import UUID + +from langchain_core.callbacks import AsyncCallbackHandler, BaseCallbackHandler + + +def _default_approve(_input: str) -> bool: + msg = ( + "Do you approve of the following input? " + "Anything except 'Y'/'Yes' (case-insensitive) will be treated as a no." + ) + msg += "\n\n" + _input + "\n" + resp = input(msg) + return resp.lower() in ("yes", "y") + + +async def _adefault_approve(_input: str) -> bool: + msg = ( + "Do you approve of the following input? " + "Anything except 'Y'/'Yes' (case-insensitive) will be treated as a no." + ) + msg += "\n\n" + _input + "\n" + resp = input(msg) + return resp.lower() in ("yes", "y") + + +def _default_true(_: Dict[str, Any]) -> bool: + return True + + +class HumanRejectedException(Exception): + """Exception to raise when a person manually review and rejects a value.""" + + +class HumanApprovalCallbackHandler(BaseCallbackHandler): + """Callback for manually validating values.""" + + raise_error: bool = True + + def __init__( + self, + approve: Callable[[Any], bool] = _default_approve, + should_check: Callable[[Dict[str, Any]], bool] = _default_true, + ): + self._approve = approve + self._should_check = should_check + + def on_tool_start( + self, + serialized: Dict[str, Any], + input_str: str, + *, + run_id: UUID, + parent_run_id: Optional[UUID] = None, + **kwargs: Any, + ) -> Any: + if self._should_check(serialized) and not self._approve(input_str): + raise HumanRejectedException( + f"Inputs {input_str} to tool {serialized} were rejected." + ) + + +class AsyncHumanApprovalCallbackHandler(AsyncCallbackHandler): + """Asynchronous callback for manually validating values.""" + + raise_error: bool = True + + def __init__( + self, + approve: Callable[[Any], Awaitable[bool]] = _adefault_approve, + should_check: Callable[[Dict[str, Any]], bool] = _default_true, + ): + self._approve = approve + self._should_check = should_check + + async def on_tool_start( + self, + serialized: Dict[str, Any], + input_str: str, + *, + run_id: UUID, + parent_run_id: Optional[UUID] = None, + **kwargs: Any, + ) -> Any: + if self._should_check(serialized) and not await self._approve(input_str): + raise HumanRejectedException( + f"Inputs {input_str} to tool {serialized} were rejected." + ) diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/infino_callback.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/infino_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..3205737409306afecc0a91ab235273f548fabc99 --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/infino_callback.py @@ -0,0 +1,251 @@ +import time +from typing import Any, Dict, List, Optional, cast + +from langchain_core.agents import AgentAction, AgentFinish +from langchain_core.callbacks import BaseCallbackHandler +from langchain_core.messages import BaseMessage +from langchain_core.outputs import ChatGeneration, LLMResult +from langchain_core.utils import guard_import + + +def import_infino() -> Any: + """Import the infino client.""" + return guard_import("infinopy").InfinoClient() + + +def import_tiktoken() -> Any: + """Import tiktoken for counting tokens for OpenAI models.""" + return guard_import("tiktoken") + + +def get_num_tokens(string: str, openai_model_name: str) -> int: + """Calculate num tokens for OpenAI with tiktoken package. + + Official documentation: https://github.com/openai/openai-cookbook/blob/main + /examples/How_to_count_tokens_with_tiktoken.ipynb + """ + tiktoken = import_tiktoken() + + encoding = tiktoken.encoding_for_model(openai_model_name) + num_tokens = len(encoding.encode(string)) + return num_tokens + + +class InfinoCallbackHandler(BaseCallbackHandler): + """Callback Handler that logs to Infino.""" + + def __init__( + self, + model_id: Optional[str] = None, + model_version: Optional[str] = None, + verbose: bool = False, + ) -> None: + # Set Infino client + self.client = import_infino() + self.model_id = model_id + self.model_version = model_version + self.verbose = verbose + self.is_chat_openai_model = False + self.chat_openai_model_name = "gpt-3.5-turbo" + + def _send_to_infino( + self, + key: str, + value: Any, + is_ts: bool = True, + ) -> None: + """Send the key-value to Infino. + + Parameters: + key (str): the key to send to Infino. + value (Any): the value to send to Infino. + is_ts (bool): if True, the value is part of a time series, else it + is sent as a log message. + """ + payload = { + "date": int(time.time()), + key: value, + "labels": { + "model_id": self.model_id, + "model_version": self.model_version, + }, + } + if self.verbose: + print(f"Tracking {key} with Infino: {payload}") # noqa: T201 + + # Append to Infino time series only if is_ts is True, otherwise + # append to Infino log. + if is_ts: + self.client.append_ts(payload) + else: + self.client.append_log(payload) + + def on_llm_start( + self, + serialized: Dict[str, Any], + prompts: List[str], + **kwargs: Any, + ) -> None: + """Log the prompts to Infino, and set start time and error flag.""" + for prompt in prompts: + self._send_to_infino("prompt", prompt, is_ts=False) + + # Set the error flag to indicate no error (this will get overridden + # in on_llm_error if an error occurs). + self.error = 0 + + # Set the start time (so that we can calculate the request + # duration in on_llm_end). + self.start_time = time.time() + + def on_llm_new_token(self, token: str, **kwargs: Any) -> None: + """Do nothing when a new token is generated.""" + pass + + def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None: + """Log the latency, error, token usage, and response to Infino.""" + # Calculate and track the request latency. + self.end_time = time.time() + duration = self.end_time - self.start_time + self._send_to_infino("latency", duration) + + # Track success or error flag. + self._send_to_infino("error", self.error) + + # Track prompt response. + for generations in response.generations: + for generation in generations: + self._send_to_infino("prompt_response", generation.text, is_ts=False) + + # Track token usage (for non-chat models). + if (response.llm_output is not None) and isinstance(response.llm_output, Dict): + token_usage = response.llm_output["token_usage"] + if token_usage is not None: + prompt_tokens = token_usage["prompt_tokens"] + total_tokens = token_usage["total_tokens"] + completion_tokens = token_usage["completion_tokens"] + self._send_to_infino("prompt_tokens", prompt_tokens) + self._send_to_infino("total_tokens", total_tokens) + self._send_to_infino("completion_tokens", completion_tokens) + + # Track completion token usage (for openai chat models). + if self.is_chat_openai_model: + messages = " ".join( + cast(str, cast(ChatGeneration, generation).message.content) + for generation in generations + ) + completion_tokens = get_num_tokens( + messages, openai_model_name=self.chat_openai_model_name + ) + self._send_to_infino("completion_tokens", completion_tokens) + + def on_llm_error(self, error: BaseException, **kwargs: Any) -> None: + """Set the error flag.""" + self.error = 1 + + def on_chain_start( + self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any + ) -> None: + """Do nothing when LLM chain starts.""" + pass + + def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None: + """Do nothing when LLM chain ends.""" + pass + + def on_chain_error(self, error: BaseException, **kwargs: Any) -> None: + """Need to log the error.""" + pass + + def on_tool_start( + self, + serialized: Dict[str, Any], + input_str: str, + **kwargs: Any, + ) -> None: + """Do nothing when tool starts.""" + pass + + def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any: + """Do nothing when agent takes a specific action.""" + pass + + def on_tool_end( + self, + output: str, + observation_prefix: Optional[str] = None, + llm_prefix: Optional[str] = None, + **kwargs: Any, + ) -> None: + """Do nothing when tool ends.""" + pass + + def on_tool_error(self, error: BaseException, **kwargs: Any) -> None: + """Do nothing when tool outputs an error.""" + pass + + def on_text(self, text: str, **kwargs: Any) -> None: + """Do nothing.""" + pass + + def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None: + """Do nothing.""" + pass + + def on_chat_model_start( + self, + serialized: Dict[str, Any], + messages: List[List[BaseMessage]], + **kwargs: Any, + ) -> None: + """Run when LLM starts running.""" + + # Currently, for chat models, we only support input prompts for ChatOpenAI. + # Check if this model is a ChatOpenAI model. + values = serialized.get("id") + if values: + for value in values: + if value == "ChatOpenAI": + self.is_chat_openai_model = True + break + + # Track prompt tokens for ChatOpenAI model. + if self.is_chat_openai_model: + invocation_params = kwargs.get("invocation_params") + if invocation_params: + model_name = invocation_params.get("model_name") + if model_name: + self.chat_openai_model_name = model_name + prompt_tokens = 0 + for message_list in messages: + message_string = " ".join( + cast(str, msg.content) for msg in message_list + ) + num_tokens = get_num_tokens( + message_string, + openai_model_name=self.chat_openai_model_name, + ) + prompt_tokens += num_tokens + + self._send_to_infino("prompt_tokens", prompt_tokens) + + if self.verbose: + print( # noqa: T201 + f"on_chat_model_start: is_chat_openai_model= \ + {self.is_chat_openai_model}, \ + chat_openai_model_name={self.chat_openai_model_name}" + ) + + # Send the prompt to infino + prompt = " ".join( + cast(str, msg.content) for sublist in messages for msg in sublist + ) + self._send_to_infino("prompt", prompt, is_ts=False) + + # Set the error flag to indicate no error (this will get overridden + # in on_llm_error if an error occurs). + self.error = 0 + + # Set the start time (so that we can calculate the request + # duration in on_llm_end). + self.start_time = time.time() diff --git a/python/user_packages/Python313/site-packages/langchain_community/callbacks/labelstudio_callback.py b/python/user_packages/Python313/site-packages/langchain_community/callbacks/labelstudio_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..0eb35af10171854afdce0860a706ee1234603e81 --- /dev/null +++ b/python/user_packages/Python313/site-packages/langchain_community/callbacks/labelstudio_callback.py @@ -0,0 +1,390 @@ +import os +import warnings +from datetime import datetime +from enum import Enum +from typing import Any, Dict, List, Optional, Tuple, Union +from uuid import UUID + +from langchain_core.agents import AgentAction, AgentFinish +from langchain_core.callbacks import BaseCallbackHandler +from langchain_core.messages import BaseMessage, ChatMessage +from langchain_core.outputs import Generation, LLMResult + + +class LabelStudioMode(Enum): + """Label Studio mode enumerator.""" + + PROMPT = "prompt" + CHAT = "chat" + + +def get_default_label_configs( + mode: Union[str, LabelStudioMode], +) -> Tuple[str, LabelStudioMode]: + """Get default Label Studio configs for the given mode. + + Parameters: + mode: Label Studio mode ("prompt" or "chat") + + Returns: Tuple of Label Studio config and mode + """ + _default_label_configs = { + LabelStudioMode.PROMPT.value: """ + + + + + + +