lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/__main__.py

@@ -0,0 +1,25 @@
+"""LFX CLI entry point."""
+
+import typer
+
+from lfx.cli.commands import serve_command
+from lfx.cli.run import run
+
+app = typer.Typer(
+    name="lfx",
+    help="lfx - Langflow Executor",
+    add_completion=False,
+)
+
+# Add commands
+app.command(name="serve", help="Serve a flow as an API", no_args_is_help=True)(serve_command)
+app.command(name="run", help="Run a flow directly", no_args_is_help=True)(run)
+
+
+def main():
+    """Main entry point for the LFX CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

lfx/base/agents/agent.py

@@ -0,0 +1,268 @@
+import re
+import uuid
+from abc import abstractmethod
+from typing import TYPE_CHECKING, cast
+
+from langchain.agents import AgentExecutor, BaseMultiActionAgent, BaseSingleActionAgent
+from langchain.agents.agent import RunnableAgent
+from langchain_core.messages import HumanMessage
+from langchain_core.runnables import Runnable
+
+from lfx.base.agents.callback import AgentAsyncHandler
+from lfx.base.agents.events import ExceptionWithMessageError, process_agent_events
+from lfx.base.agents.utils import data_to_messages
+from lfx.custom.custom_component.component import Component, _get_component_toolkit
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import InputTypes, MultilineInput
+from lfx.io import BoolInput, HandleInput, IntInput, MessageInput
+from lfx.log.logger import logger
+from lfx.memory import delete_message
+from lfx.schema.content_block import ContentBlock
+from lfx.schema.data import Data
+from lfx.schema.message import Message
+from lfx.template.field.base import Output
+from lfx.utils.constants import MESSAGE_SENDER_AI
+
+if TYPE_CHECKING:
+    from langchain_core.messages import BaseMessage
+
+    from lfx.schema.log import SendMessageFunctionType
+
+
+DEFAULT_TOOLS_DESCRIPTION = "A helpful assistant with access to the following tools:"
+DEFAULT_AGENT_NAME = "Agent ({tools_names})"
+
+
+class LCAgentComponent(Component):
+    trace_type = "agent"
+    _base_inputs: list[InputTypes] = [
+        MessageInput(
+            name="input_value",
+            display_name="Input",
+            info="The input provided by the user for the agent to process.",
+            tool_mode=True,
+        ),
+        BoolInput(
+            name="handle_parsing_errors",
+            display_name="Handle Parse Errors",
+            value=True,
+            advanced=True,
+            info="Should the Agent fix errors when reading user input for better processing?",
+        ),
+        BoolInput(name="verbose", display_name="Verbose", value=True, advanced=True),
+        IntInput(
+            name="max_iterations",
+            display_name="Max Iterations",
+            value=15,
+            advanced=True,
+            info="The maximum number of attempts the agent can make to complete its task before it stops.",
+        ),
+        MultilineInput(
+            name="agent_description",
+            display_name="Agent Description [Deprecated]",
+            info=(
+                "The description of the agent. This is only used when in Tool Mode. "
+                f"Defaults to '{DEFAULT_TOOLS_DESCRIPTION}' and tools are added dynamically. "
+                "This feature is deprecated and will be removed in future versions."
+            ),
+            advanced=True,
+            value=DEFAULT_TOOLS_DESCRIPTION,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Agent", name="agent", method="build_agent", hidden=True, tool_mode=False),
+        Output(display_name="Response", name="response", method="message_response"),
+    ]
+
+    @abstractmethod
+    def build_agent(self) -> AgentExecutor:
+        """Create the agent."""
+
+    async def message_response(self) -> Message:
+        """Run the agent and return the response."""
+        agent = self.build_agent()
+        message = await self.run_agent(agent=agent)
+
+        self.status = message
+        return message
+
+    def _validate_outputs(self) -> None:
+        required_output_methods = ["build_agent"]
+        output_names = [output.name for output in self.outputs]
+        for method_name in required_output_methods:
+            if method_name not in output_names:
+                msg = f"Output with name '{method_name}' must be defined."
+                raise ValueError(msg)
+            if not hasattr(self, method_name):
+                msg = f"Method '{method_name}' must be defined."
+                raise ValueError(msg)
+
+    def get_agent_kwargs(self, *, flatten: bool = False) -> dict:
+        base = {
+            "handle_parsing_errors": self.handle_parsing_errors,
+            "verbose": self.verbose,
+            "allow_dangerous_code": True,
+        }
+        agent_kwargs = {
+            "handle_parsing_errors": self.handle_parsing_errors,
+            "max_iterations": self.max_iterations,
+        }
+        if flatten:
+            return {
+                **base,
+                **agent_kwargs,
+            }
+        return {**base, "agent_executor_kwargs": agent_kwargs}
+
+    def get_chat_history_data(self) -> list[Data] | None:
+        # might be overridden in subclasses
+        return None
+
+    async def run_agent(
+        self,
+        agent: Runnable | BaseSingleActionAgent | BaseMultiActionAgent | AgentExecutor,
+    ) -> Message:
+        if isinstance(agent, AgentExecutor):
+            runnable = agent
+        else:
+            # note the tools are not required to run the agent, hence the validation removed.
+            handle_parsing_errors = hasattr(self, "handle_parsing_errors") and self.handle_parsing_errors
+            verbose = hasattr(self, "verbose") and self.verbose
+            max_iterations = hasattr(self, "max_iterations") and self.max_iterations
+            runnable = AgentExecutor.from_agent_and_tools(
+                agent=agent,
+                tools=self.tools or [],
+                handle_parsing_errors=handle_parsing_errors,
+                verbose=verbose,
+                max_iterations=max_iterations,
+            )
+        input_dict: dict[str, str | list[BaseMessage]] = {
+            "input": self.input_value.to_lc_message() if isinstance(self.input_value, Message) else self.input_value
+        }
+        if hasattr(self, "system_prompt"):
+            input_dict["system_prompt"] = self.system_prompt
+        if hasattr(self, "chat_history") and self.chat_history:
+            if isinstance(self.chat_history, Data):
+                input_dict["chat_history"] = data_to_messages(self.chat_history)
+            if all(isinstance(m, Message) for m in self.chat_history):
+                input_dict["chat_history"] = data_to_messages([m.to_data() for m in self.chat_history])
+        if hasattr(input_dict["input"], "content") and isinstance(input_dict["input"].content, list):
+            # ! Because the input has to be a string, we must pass the images in the chat_history
+
+            image_dicts = [item for item in input_dict["input"].content if item.get("type") == "image"]
+            input_dict["input"].content = [item for item in input_dict["input"].content if item.get("type") != "image"]
+
+            if "chat_history" not in input_dict:
+                input_dict["chat_history"] = []
+            if isinstance(input_dict["chat_history"], list):
+                input_dict["chat_history"].extend(HumanMessage(content=[image_dict]) for image_dict in image_dicts)
+            else:
+                input_dict["chat_history"] = [HumanMessage(content=[image_dict]) for image_dict in image_dicts]
+
+        if hasattr(self, "graph"):
+            session_id = self.graph.session_id
+        elif hasattr(self, "_session_id"):
+            session_id = self._session_id
+        else:
+            session_id = None
+
+        agent_message = Message(
+            sender=MESSAGE_SENDER_AI,
+            sender_name=self.display_name or "Agent",
+            properties={"icon": "Bot", "state": "partial"},
+            content_blocks=[ContentBlock(title="Agent Steps", contents=[])],
+            session_id=session_id or uuid.uuid4(),
+        )
+        try:
+            result = await process_agent_events(
+                runnable.astream_events(
+                    input_dict,
+                    config={"callbacks": [AgentAsyncHandler(self.log), *self.get_langchain_callbacks()]},
+                    version="v2",
+                ),
+                agent_message,
+                cast("SendMessageFunctionType", self.send_message),
+            )
+        except ExceptionWithMessageError as e:
+            if hasattr(e, "agent_message") and hasattr(e.agent_message, "id"):
+                msg_id = e.agent_message.id
+                await delete_message(id_=msg_id)
+            await self._send_message_event(e.agent_message, category="remove_message")
+            logger.error(f"ExceptionWithMessageError: {e}")
+            raise
+        except Exception as e:
+            # Log or handle any other exceptions
+            logger.error(f"Error: {e}")
+            raise
+
+        self.status = result
+        return result
+
+    @abstractmethod
+    def create_agent_runnable(self) -> Runnable:
+        """Create the agent."""
+
+    def validate_tool_names(self) -> None:
+        """Validate tool names to ensure they match the required pattern."""
+        pattern = re.compile(r"^[a-zA-Z0-9_-]+$")
+        if hasattr(self, "tools") and self.tools:
+            for tool in self.tools:
+                if not pattern.match(tool.name):
+                    msg = (
+                        f"Invalid tool name '{tool.name}': must only contain letters, numbers, underscores, dashes,"
+                        " and cannot contain spaces."
+                    )
+                    raise ValueError(msg)
+
+
+class LCToolsAgentComponent(LCAgentComponent):
+    _base_inputs = [
+        HandleInput(
+            name="tools",
+            display_name="Tools",
+            input_types=["Tool"],
+            is_list=True,
+            required=False,
+            info="These are the tools that the agent can use to help with tasks.",
+        ),
+        *LCAgentComponent.get_base_inputs(),
+    ]
+
+    def build_agent(self) -> AgentExecutor:
+        self.validate_tool_names()
+        agent = self.create_agent_runnable()
+        return AgentExecutor.from_agent_and_tools(
+            agent=RunnableAgent(runnable=agent, input_keys_arg=["input"], return_keys_arg=["output"]),
+            tools=self.tools,
+            **self.get_agent_kwargs(flatten=True),
+        )
+
+    @abstractmethod
+    def create_agent_runnable(self) -> Runnable:
+        """Create the agent."""
+
+    def get_tool_name(self) -> str:
+        return self.display_name or "Agent"
+
+    def get_tool_description(self) -> str:
+        return self.agent_description or DEFAULT_TOOLS_DESCRIPTION
+
+    def _build_tools_names(self):
+        tools_names = ""
+        if self.tools:
+            tools_names = ", ".join([tool.name for tool in self.tools])
+        return tools_names
+
+    def _get_tools(self) -> list[Tool]:
+        component_toolkit = _get_component_toolkit()
+        tools_names = self._build_tools_names()
+        agent_description = self.get_tool_description()
+        # TODO: Agent Description Depreciated Feature to be removed
+        description = f"{agent_description}{tools_names}"
+        tools = component_toolkit(component=self).get_tools(
+            tool_name=self.get_tool_name(), tool_description=description, callbacks=self.get_langchain_callbacks()
+        )
+        if hasattr(self, "tools_metadata"):
+            tools = component_toolkit(component=self, metadata=self.tools_metadata).update_tools_metadata(tools=tools)
+        return tools

lfx/base/agents/callback.py

@@ -0,0 +1,130 @@
+from typing import Any
+from uuid import UUID
+
+from langchain.callbacks.base import AsyncCallbackHandler
+from langchain_core.agents import AgentAction, AgentFinish
+
+from lfx.schema.log import LogFunctionType
+
+
+class AgentAsyncHandler(AsyncCallbackHandler):
+    """Async callback handler that can be used to handle callbacks from langchain."""
+
+    def __init__(self, log_function: LogFunctionType | None = None):
+        self.log_function = log_function
+
+    async def on_chain_start(
+        self,
+        serialized: dict[str, Any],
+        inputs: dict[str, Any],
+        *,
+        run_id: UUID,
+        parent_run_id: UUID | None = None,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if self.log_function is None:
+            return
+        self.log_function(
+            {
+                "type": "chain_start",
+                "serialized": serialized,
+                "inputs": inputs,
+                "run_id": run_id,
+                "parent_run_id": parent_run_id,
+                "tags": tags,
+                "metadata": metadata,
+                **kwargs,
+            },
+            name="Chain Start",
+        )
+
+    async def on_tool_start(
+        self,
+        serialized: dict[str, Any],
+        input_str: str,
+        *,
+        run_id: UUID,
+        parent_run_id: UUID | None = None,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+        inputs: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if self.log_function is None:
+            return
+        self.log_function(
+            {
+                "type": "tool_start",
+                "serialized": serialized,
+                "input_str": input_str,
+                "run_id": run_id,
+                "parent_run_id": parent_run_id,
+                "tags": tags,
+                "metadata": metadata,
+                "inputs": inputs,
+                **kwargs,
+            },
+            name="Tool Start",
+        )
+
+    async def on_tool_end(self, output: Any, *, run_id: UUID, parent_run_id: UUID | None = None, **kwargs: Any) -> None:
+        if self.log_function is None:
+            return
+        self.log_function(
+            {
+                "type": "tool_end",
+                "output": output,
+                "run_id": run_id,
+                "parent_run_id": parent_run_id,
+                **kwargs,
+            },
+            name="Tool End",
+        )
+
+    async def on_agent_action(
+        self,
+        action: AgentAction,
+        *,
+        run_id: UUID,
+        parent_run_id: UUID | None = None,
+        tags: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if self.log_function is None:
+            return
+        self.log_function(
+            {
+                "type": "agent_action",
+                "action": action,
+                "run_id": run_id,
+                "parent_run_id": parent_run_id,
+                "tags": tags,
+                **kwargs,
+            },
+            name="Agent Action",
+        )
+
+    async def on_agent_finish(
+        self,
+        finish: AgentFinish,
+        *,
+        run_id: UUID,
+        parent_run_id: UUID | None = None,
+        tags: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if self.log_function is None:
+            return
+        self.log_function(
+            {
+                "type": "agent_finish",
+                "finish": finish,
+                "run_id": run_id,
+                "parent_run_id": parent_run_id,
+                "tags": tags,
+                **kwargs,
+            },
+            name="Agent Finish",
+        )

lfx/base/agents/context.py

@@ -0,0 +1,109 @@
+from datetime import datetime, timezone
+from typing import Any
+
+from langchain_core.language_models import BaseLanguageModel, BaseLLM
+from langchain_core.language_models.chat_models import BaseChatModel
+from pydantic import BaseModel, Field, field_validator, model_serializer
+
+from lfx.field_typing import LanguageModel
+from lfx.schema.data import Data
+
+
+class AgentContext(BaseModel):
+    tools: dict[str, Any]
+    llm: Any
+    context: str = ""
+    iteration: int = 0
+    max_iterations: int = 5
+    thought: str = ""
+    last_action: Any = None
+    last_action_result: Any = None
+    final_answer: Any = ""
+    context_history: list[tuple[str, str, str]] = Field(default_factory=list)
+
+    @model_serializer(mode="plain")
+    def serialize_agent_context(self):
+        serliazed_llm = self.llm.to_json() if hasattr(self.llm, "to_json") else str(self.llm)
+        serliazed_tools = {k: v.to_json() if hasattr(v, "to_json") else str(v) for k, v in self.tools.items()}
+        return {
+            "tools": serliazed_tools,
+            "llm": serliazed_llm,
+            "context": self.context,
+            "iteration": self.iteration,
+            "max_iterations": self.max_iterations,
+            "thought": self.thought,
+            "last_action": self.last_action.to_json()
+            if hasattr(self.last_action, "to_json")
+            else str(self.last_action),
+            "action_result": self.last_action_result.to_json()
+            if hasattr(self.last_action_result, "to_json")
+            else str(self.last_action_result),
+            "final_answer": self.final_answer,
+            "context_history": self.context_history,
+        }
+
+    @field_validator("llm", mode="before")
+    @classmethod
+    def validate_llm(cls, v) -> LanguageModel:
+        if not isinstance(v, BaseLLM | BaseChatModel | BaseLanguageModel):
+            msg = "llm must be an instance of LanguageModel"
+            raise TypeError(msg)
+        return v
+
+    def to_data_repr(self):
+        data_objs = []
+        for name, val, time_str in self.context_history:
+            content = val.content if hasattr(val, "content") else val
+            data_objs.append(Data(name=name, value=content, timestamp=time_str))
+
+        sorted_data_objs = sorted(data_objs, key=lambda x: datetime.fromisoformat(x.timestamp), reverse=True)
+
+        sorted_data_objs.append(
+            Data(
+                name="Formatted Context",
+                value=self.get_full_context(),
+            )
+        )
+        return sorted_data_objs
+
+    def _build_tools_context(self):
+        tool_context = ""
+        for tool_name, tool_obj in self.tools.items():
+            tool_context += f"{tool_name}: {tool_obj.description}\n"
+        return tool_context
+
+    def _build_init_context(self):
+        return f"""
+{self.context}
+
+"""
+
+    def model_post_init(self, _context: Any) -> None:
+        if hasattr(self.llm, "bind_tools"):
+            self.llm = self.llm.bind_tools(self.tools.values())
+        if self.context:
+            self.update_context("Initial Context", self.context)
+
+    def update_context(self, key: str, value: str):
+        self.context_history.insert(0, (key, value, datetime.now(tz=timezone.utc).astimezone().isoformat()))
+
+    def _serialize_context_history_tuple(self, context_history_tuple: tuple[str, str, str]) -> str:
+        name, value, _ = context_history_tuple
+        if hasattr(value, "content"):
+            value = value.content
+        elif hasattr(value, "log"):
+            value = value.log
+        return f"{name}: {value}"
+
+    def get_full_context(self) -> str:
+        context_history_reversed = self.context_history[::-1]
+        context_formatted = "\n".join(
+            [
+                self._serialize_context_history_tuple(context_history_tuple)
+                for context_history_tuple in context_history_reversed
+            ]
+        )
+        return f"""
+Context:
+{context_formatted}
+"""