connecting 2 custom components

[SVyusti]

is there a way in which a python function can be sent as a tool to a custom component to perform a simple task.
also how to create an input for a custom component which is provided by connecting another component in it?

[dosubot[bot]]

Hey @SVyusti! 👋 I'm here to help you with any questions or issues you have. Let's tackle this together!

To send a Python function as a tool to a custom component and create an input for a custom component that is provided by connecting another component to it, you can use the PythonFunctionTool class. Here’s how you can achieve this:

1. Define the Python Function Tool:
   The PythonFunctionTool class allows you to define a Python function by providing the function code.

2. Build the Configuration:
   The __init__ method specifies the configuration for the component, including the function code.

3. Build the Function:
   The get_function method takes the function code as input, retrieves the function using validate.create_function, and returns it as a callable.

Here is an example:

from langflow.interface.importing.utils import get_function
from langflow.utils import validate
from langchain.agents.tools import Tool

class Function(BaseModel):
    code: str
    function: Optional[Callable] = None
    imports: Optional[str] = None

    def __init__(self, **data):
        super().__init__(**data)

    @validator("code")
    def validate_func(cls, v):
        try:
            validate.eval_function(v)
        except Exception as e:
            raise e
        return v

    def get_function(self):
        """Get the function"""
        function_name = validate.extract_function_name(self.code)
        return validate.create_function(self.code, function_name)

class PythonFunctionTool(Function, Tool):
    name: str = "Custom Tool"
    description: str
    code: str

    def __init__(self, name: str, description: str, code: str):
        self.name = name
        self.description = description
        self.code = code
        self.func = self.get_function()
        super().__init__(name=name, description=description, func=self.func)

# Example usage
function_code = """
def my_function(x):
    return x * 2
"""

component = PythonFunctionTool(name="Multiplier", description="Multiplies input by 2", code=function_code)

# Now you can use the function
result = component.func(5)
print(result)  # Output: 10

To create an input for a custom component that is provided by connecting another component to it, you would typically use the framework's capabilities to connect components and pass data between them. This part is specific to how Langflow handles component connections and data flow ^[1].

Langflow handles the connection and data flow between different components in the UI by using a combination of React hooks, state management, and component composition. Specifically, it uses the useEffect hook to set the current flow ID based on the URL parameters, and it manages state using custom stores (useFlowsManagerStore and useDarkStore). The FlowPage component then conditionally renders other components based on the current state and props ^[2].

For more detailed examples and documentation on creating and connecting custom components, you can refer to the "docs/docs/administration/custom-component.mdx" file in the Langflow repository ^[3].

To continue talking to Dosu, mention @dosu.

[SVyusti]

how can we call this function in another component?

[dosubot[bot]]

To call a function from one custom component in another component within Langflow, you can use the get_function method to dynamically load and execute the function. Here's a step-by-step guide on how to achieve this:

1. Define the Function in the First Component:
   Ensure that the function you want to call is defined and accessible in the first component.

2. Expose the Function:
   Use the get_function method to extract and expose the function from the first component.

3. Call the Function in the Second Component:
   In the second component, use the exposed function to perform the desired task.

Here is an example to illustrate this process:

First Component (Defining and Exposing the Function)

from langflow.custom import CustomComponent
from langflow.utils import validate

class FirstComponent(CustomComponent):
    display_name = "First Component"
    description = "This component defines a function"

    def build(self):
        # Define the function code
        function_code = """
def multiply_by_two(x):
    return x * 2
"""
        # Expose the function using get_function
        self.exposed_function = self.get_function(function_code)

    def get_function(self, code):
        """Get the function"""
        function_name = validate.extract_function_name(code)
        return validate.create_function(code, function_name)

Second Component (Calling the Exposed Function)

from langflow.custom import CustomComponent

class SecondComponent(CustomComponent):
    display_name = "Second Component"
    description = "This component calls a function from another component"

    def build(self, first_component: FirstComponent, input_value: int):
        # Call the exposed function from the first component
        result = first_component.exposed_function(input_value)
        self.repr_value = f"Result of multiply_by_two: {result}"
        return result

Usage Example

# Instantiate the first component and build it to expose the function
first_component = FirstComponent()
first_component.build()

# Instantiate the second component and call the function from the first component
second_component = SecondComponent()
result = second_component.build(first_component, 5)
print(result)  # Output: 10

In this example, the FirstComponent defines a function multiply_by_two and exposes it using the get_function method. The SecondComponent then calls this exposed function, passing the necessary input value and obtaining the result.

By following this approach, you can dynamically load and call functions from one custom component in another within Langflow ^[1].

To continue talking to Dosu, mention @dosu.

[SVyusti]

second component requires first component as an input , how to modify the first component to pass the function

[dosubot[bot]]

To modify the FirstComponent to pass its function as an input to the SecondComponent, you need to ensure that the function from FirstComponent is passed down as a prop to SecondComponent. Here is an example of how you can achieve this:

FirstComponent

import React from 'react';
import SecondComponent from './SecondComponent';

export default function FirstComponent() {
  const multiplyByTwo = (x: number) => {
    return x * 2;
  };

  return (
    <div>
      <h1>First Component</h1>
      <SecondComponent multiplyFunction={multiplyByTwo} />
    </div>
  );
}

SecondComponent

import React from 'react';

interface SecondComponentProps {
  multiplyFunction: (x: number) => number;
}

export default function SecondComponent({ multiplyFunction }: SecondComponentProps) {
  const handleMultiply = () => {
    const result = multiplyFunction(5);
    console.log("Result of multiplyByTwo:", result);
  };

  return (
    <div>
      <h2>Second Component</h2>
      <button onClick={handleMultiply}>Multiply by Two</button>
    </div>
  );
}

In this example, FirstComponent defines a function multiplyByTwo and passes it as a prop to SecondComponent. SecondComponent then uses this function when the button is clicked, demonstrating how to pass and use a function from one component in another.

To continue talking to Dosu, mention @dosu.

[SVyusti]

both should be langflow custom component

[dosubot[bot]]

To modify two Langflow custom components so that the first component can pass a function to the second component, you can follow these steps:

1. Modify the first component to include a function that it will pass to the second component.
2. Modify the second component to accept and utilize the function passed from the first component.

Here is an example of how you can achieve this:

First Component (FunctionProviderComponent)

from typing import Callable
from langflow.interface.custom.custom_component import CustomComponent
from langflow.schema import Record

class FunctionProviderComponent(CustomComponent):
    display_name = "Function Provider"
    description = "Provides a function to be used by another component."

    def build_config(self) -> dict:
        return {
            "function_name": {
                "display_name": "Function Name",
                "info": "Name of the function to provide.",
                "input_types": ["Text"],
            },
        }

    def build(self, function_name: str) -> Record:
        def example_function(x):
            return f"Function {function_name} called with argument {x}"
        
        return Record(data=example_function)

Second Component (FunctionConsumerComponent)

from typing import Callable
from langflow.interface.custom.custom_component import CustomComponent
from langflow.schema import Record

class FunctionConsumerComponent(CustomComponent):
    display_name = "Function Consumer"
    description = "Consumes a function provided by another component."

    def build_config(self) -> dict:
        return {
            "input_value": {
                "display_name": "Input Value",
                "info": "Value to pass to the function.",
                "input_types": ["Text"],
            },
            "function": {
                "display_name": "Function",
                "info": "Function to be consumed.",
                "input_types": ["Callable"],
            },
        }

    def build(self, input_value: str, function: Callable) -> Record:
        result = function(input_value)
        return Record(data=result)

In this setup:

• The FunctionProviderComponent provides a function based on the input function_name.
• The FunctionConsumerComponent accepts a function and an input value, then calls the function with the input value and returns the result.

This way, the first component can pass a function to the second component within the Langflow framework ^[1][2].

To continue talking to Dosu, mention @dosu.

[SVyusti]

@dosu Can a state be passed from one custom component to another in langflow?

[dosubot[bot]]

Yes, a state can be passed from one custom component to another in Langflow. You can achieve this by using the PassComponent, which forwards the second input (forwarded_input) while ignoring the first input (ignored_input). This allows you to control the workflow direction and pass the state to another component.

Here is an example of how you can use the PassComponent to pass state:

from typing import Union
from langflow.custom import CustomComponent
from langflow.field_typing import Text
from langflow.schema import Record

class PassComponent(CustomComponent):
    display_name = "Pass"
    description = "A pass-through component that forwards the second input while ignoring the first, used for controlling workflow direction."
    field_order = ["ignored_input", "forwarded_input"]

    def build_config(self) -> dict:
        return {
            "ignored_input": {
                "display_name": "Ignored Input",
                "info": "This input is ignored. It's used to control the flow in the graph.",
                "input_types": ["Text", "Record"],
            },
            "forwarded_input": {
                "display_name": "Input",
                "info": "This input is forwarded by the component.",
                "input_types": ["Text", "Record"],
            },
        }

    def build(self, ignored_input: Text, forwarded_input: Text) -> Union[Text, Record]:
        # The ignored_input is not used in the logic, it's just there for graph flow control
        self.status = forwarded_input
        return forwarded_input

In this example, the PassComponent takes two inputs: ignored_input and forwarded_input. The forwarded_input is the state that you want to pass to another component. The ignored_input is not used in the logic but is there to control the flow in the graph. The forwarded_input is then returned and can be passed to another component ^[1].

To continue talking to Dosu, mention @dosu.

[SVyusti]

@dosu share the contents of a "with statement" over all the custom components connected to this component

[dosubot[bot]]

To share the contents of a "with statement" across all custom components connected to a specific component in Langflow, you can follow these steps:

1. Create a Custom Component Class: Inherit from the CustomComponent class and override the necessary methods.
2. Implement the build_config Method: Define the configuration options for your custom component.
3. Implement the build Method: Use the "with statement" to manage resources and share the contents with connected components.

Here is an example of how you might implement such a custom component:

Custom Component with "with statement"

from langflow.interface.custom.custom_component import CustomComponent
from langflow.schema import Record

class SharedResourceComponent(CustomComponent):
    display_name = "Shared Resource Component"
    description = "A component that shares the contents of a 'with statement' with all connected custom components."

    def build_config(self):
        return {
            "file_path": {
                "type": "string",
                "default": "default_file.txt",
                "description": "Path to the file to be read."
            }
        }

    def build(self, config):
        file_path = config.get("file_path", "default_file.txt")
        
        # Using a with statement to manage resources
        with open(file_path, 'r') as file:
            data = file.read()
        
        # Share the data with all connected custom components
        self.shared_data = data
        
        return Record(data=data)

Connected Component

from langflow.interface.custom.custom_component import CustomComponent
from langflow.schema import Record

class ConsumerComponent(CustomComponent):
    display_name = "Consumer Component"
    description = "A component that consumes shared data from another component."

    def build_config(self):
        return {
            "shared_data": {
                "type": "string",
                "description": "Data shared from another component."
            }
        }

    def build(self, shared_data: str):
        # Process the shared data
        processed_data = f"Processed: {shared_data}"
        
        return Record(data=processed_data)

Usage

1. Add the SharedResourceComponent to your flow: This component will read the file and share its contents.
2. Connect the SharedResourceComponent to the ConsumerComponent: The ConsumerComponent will receive the shared data and process it.

By following this approach, you can effectively share the contents of a "with statement" across all connected custom components in Langflow ^[1].

To continue talking to Dosu, mention @dosu.