We propose a pipeline prompt that can be used in router chains(Multi-prompt).

[YamonBot]

As shown in the above concept, we have created a custom prompter chain that can configure a pipeline by connecting Python function tools and other prompters.

It is a structure that is driven partially by comparing the Name field of the Python function tool with the value in the prompter.

Through this, you can check the time in real time within the prompter or insert data in time series format directly into the prompter, and since it has its own Name field, it can be operated as a multiprompter later. (Confirmed direct operation)

from typing import List, Optional, Tuple
from langflow import CustomComponent
from langchain.prompts import PromptTemplate
from langchain.prompts.pipeline import PipelinePromptTemplate
from pprint import pprint
from langchain.tools import Tool
from langflow.interface.utils import extract_input_variables_from_prompt
from langchain.schema import BasePromptTemplate
from langflow.interface.prompts.custom import HyperPrompt
from langflow.interface.prompts.custom import BaseCustomPrompt


class HyperPromptTemplate(CustomComponent):
    display_name: str = "HyperPromptTemplate"
    description: str = " highly."

    def build_config(self):

        return {
            "promptrompt_description": {"display_name": "Prompt description"},
            "prompt_name": {"value": "HyperPrompt", "display_name": "Prompt name"},
            "ai_prefix": {"value": "AI", "display_name": "AI name"},
            "input_variables": {
                "display_name": "input_variables",
                "advanced": True,
                "info": "If the Tool's Name matches a given value, such as 'Time,' set its output to 'Partial.",
            },
            "template": {"display_name": "template", "advanced": True},
            "kargs": {"value": "None", "advanced": True},
            "partial_variables_pytool": {"display_name": "Tools", "islist": True},
            "prompt": {
                "display_name": "ptpt",
                "field_type": "Prompt",
                "value": "넌 AI 비서이고 AI상태에 따라 감정에 맞춰서 답변을 해야해\n현재시간:{date}\nAI상태:{imotion}\n대화내역:\n{chat_history}\nHuman : {input}\nAI :",
            },
            "Extra_Prompts": {"display_name": "Extra Prompts", "is_list": True},
        }

    def build(
        self,
        prompt: str,
        prompt_name: str,
        ai_prefix: str,
        input_variables: List[str],

        Extra_Prompts: Optional[List[PromptTemplate]] = None,
        # 수정: partial을 리스트로 받는다.
        partial_variables_pytool: Optional[List[Tool]] = None,
        prompt_description: Optional[str] = None,
        **kargs,

    ) -> PromptTemplate:

      #  for key, value in kargs.items():
      #     print(f"{key}: {value}")

        # input_variables = extract_input_variables_from_prompt(prompt)

        self.repr_value = {
            "Prompt": prompt,
            "Prompt Name": prompt_name,
            "AI Prefix": ai_prefix,
            "Input Variables": input_variables,
            "Extra Prompts": Extra_Prompts,
            "Partial": partial_variables_pytool,
            "Prompt Description": prompt_description,
            "Additional Arguments": kargs,
        }

        print("=" * 30)
        print("Build Parameters")
        print("=" * 30)
        pprint(self.repr_value)
        print("=" * 30)

        hyper_prompt = PromptTemplate(
            input_variables=input_variables,
            template=prompt,
            description=prompt_description,
            ai_prefix=ai_prefix,
        )

        if partial_variables_pytool:  # 수정: partial 리스트가 존재한다면
            for tool in partial_variables_pytool:  # 수정: partial 리스트를 순회
                if tool and tool.name in kargs:  # 수정: tool의 이름이 input_variables에 있다면
                    print("펑션 인풋 벨류 삭제전 ", hyper_prompt.input_variables)
                    hyper_prompt.input_variables.remove(
                        tool.name)  # 해당 이름을 input_variables에서 제거
                    print("펑션 인풋 벨류 삭제후  ", hyper_prompt.input_variables)
                    # partial_variables에 추가
                    hyper_prompt.partial_variables[tool.name] = tool.func()
                    print("펑션 파셜 벨류  ", hyper_prompt.partial_variables)

        input_prompts = []

        # output_prompt: PromptTemplate = hyper_prompt
        partial_variables = {}

        if Extra_Prompts:

            for extra_prompt in Extra_Prompts:
                if extra_prompt.prompt_info['name'] in input_variables:
                    tmpp = extra_prompt
                    input_prompts.append(
                        (extra_prompt.prompt_info['name'], tmpp))

                    # input_variables에서 해당 이름 제거
                    hyper_prompt.input_variables.remove(
                        extra_prompt.prompt_info['name'])

                    # partial_variables에 해당 이름 추가
                    partial_variables[extra_prompt.prompt_info['name']] = tmpp

                    print("매칭용", input_prompts)

        print("매칭용 파셜벨류류", partial_variables)

        pipeline_prompt = PipelinePromptTemplate(
            final_prompt=hyper_prompt,
            pipeline_prompts=input_prompts,

        )

        pipeline_prompt.__dict__['prompt_info'] = {
            "name": prompt_name,
            "description": prompt_description
        }

        pipeline_prompt.input_variables = hyper_prompt.input_variables
      #  pipeline_prompt.partial_variables=partial_variables
        pipeline_prompt.partial_variables = partial_variables

        pipeline_prompt.partial_variables.update(
            hyper_prompt.partial_variables)

        print("파이프 인펏벨륫륫", pipeline_prompt.input_variables)
        print("파이프 파셜셜륫륫", pipeline_prompt.partial_variables)

        return pipeline_prompt

Since this custom component uses the “python Function Tool”, there is no need to create a separate new widget. This functions similarly to Openai's Funtioncall by directly connecting the tools for agents to use.

By expanding in this way, it is possible to create a Langchain pipeline.

When I try "Lint" it works fine, although it has some bugs. I hope that prompt editing will become more convenient as this concept becomes a common task.

[ogabrielluiz]

Hey @yamonkjd

This looks incredible.

I never quite understand use cases for the Pipeline. Could you help me understand it?

So, the main goal of this is to have dynamic prompts but using the Python Function Tool instead?

How does that differ from having a normal PromptTemplate with many variables and then just adding components that fill that variable with whatever data you need?

Really awesome work.

Thanks for all the contributions, by the way!

[YamonBot]

Hey @yamonkjd

This looks incredible.

I never quite understand use cases for the Pipeline. Could you help me understand it?

So, the main goal of this is to have dynamic prompts but using the Python Function Tool instead?

How does that differ from having a normal PromptTemplate with many variables and then just adding components that fill that variable with whatever data you need?

Really awesome work.

Thanks for all the contributions, by the way!

The pipeline prompt in Langchain works by comparing the value of a specific prompt with the name of the prompt to combine specific areas. It then sequentially assembles them in the final prompter of the pipe, operating on this logic. My source code utilizes this design as is

However, the concept I added allows the prompter object's partial value to combine dynamic values instead of static ones, as you mentioned. This enables even models that do not support function calls to simply generate outputs without inputs by substituting the value. (ex: weather, time, status, system version ~~)

Also, as mentioned in the title, through Routerchain, the agent operates by selecting the prompter itself according to the appropriate format based on the name and description of the prompt object. Therefore, when combined with a pipeline, there's no need to create multiple instances of the same prompter, much like a class.

Through this, when the agent operates, it doesn't send useless values, allowing for flexible response to token limitations. Also, because it provides filtered values, the performance of the model can improve.

To further explain the usage example,

Q. The user asked about the weather at the current location.
case1.
-> Find the necessary tools (look at the list)
-> Select a tool -> Find the GPS value that exists in the system.
-> Find the necessary tools (look at the list)
-> Load the current location.
-> Find the necessary tools (look at the list)
-> Check the current time. ->
Find the tools you need (look at the list)
-> Call the weather API.

case2.
Weather is provided as input to the model by combining already existing values ​​(GPS, location, time). -> The model generates an answer.

case1 is the operation logic of the function call,
case2 is my logic. By reducing the process like in this case, tool calls are minimized.

And, because it uses partial values, if the Python function tool cannot provide data, it is automatically deleted from the prompter.
In other words, this method does not create a thinking process for AI.

Reference link :
https://python.langchain.com/docs/modules/model_io/prompts/prompt_templates/prompts_pipelining
https://python.langchain.com/docs/modules/model_io/prompts/prompt_templates/partial

I have verified that my logic works correctly with this code.

[YamonBot]

If you connect another hyperprompt to the hyperprompt being inputted into the model via an extra prompt, and match the variable names in the final prompt with those of the connected prompt, it will work.

[YamonBot]

I created it using the basic structure of Langchain.

Because the name and description already exist in the Python function tool, we decided to reuse the widget rather than creating a separate widget.

Due to the structure of the LangChain architecture, Python code is copied and operated from the LangChain framework, so no additional development was required, and it also works well in LangFlow.

The Python function tool is configured to have only output and no input. (If it is not an OPENAI model, parameters cannot be created and passed by the model, so it is not valid in other models such as LAMMA.)

Of course, you can expect the same effect by calling the tool, but data with only output consumes excessive resources, so this configuration is reasonable for simple data.

[YamonBot]

Currently, we are researching the logic to automatically convert and output this template into chat prompts, message prompts, and general prompts. If you think this structure is valid and can be included in the roadmap, we will create a new pull request and commit the code for that part.

Since we are trying to include too many features, if there are areas in progress with other similar goals, we will try to hold off on progress. We want to control all prompter types with one widget.

[YamonBot]

zz.mp4

An example of use is attached. However, due to a bug in my code, the last Pipe0 did not work properly.

zz2.mp4

[ogabrielluiz]

I really like this approach, @yamonkjd

It is straightforward and allowing to use simple Python functions can be great. It makes sense because variables are functions and essentially a prompt can be treated as a function too, right?

[YamonBot]

@ogabrielluiz

That's exactly what you said. Once we complete this concept, is there room for it to be merged into Dev Brunch? The main code will not be modified and only one custom component will be added. Since this prompt uses the partial values ​​and pipelines that LangChain is aiming for, it will continue to operate without problems in the future.

[ogabrielluiz]

I'm sorry for the delayed response, @yamonkjd

We have something in the works that would better credit you for the awesome work you put into this.

Could you hang tight just a little longer?

[ogabrielluiz]

@yamonkjd We'd love to see you component in the Store!

I've added a Prompt type to langflow.field_typing thinking specifically on this use case. You still have to add the **kwargs though.

[nhatpham2016]

Hi there,
let's say I want to populate the prompts from promtplayers api, a f-string. f'hello {name}'
how can I feed that into the custom component,so that it looks like a HumanMessagePromptTemplate component ?