Conditional branching. Is there a better way?

[ArmykOliva]

If you look closely on my promptflow. I first evaulate with an LLM if edits need to be done to a resume based on formatting requirements or if there are no edits required. Now if edits are required the LLM edits the template, if not I just want to pass the original data.

With current promptflow, I have to first check the answer of the LLM and pass it to a function, then either call LLM or only parse data. Then I have to junction the inputs and return the not "None" value to my final node.

Is there a better way to do this? Is there a way to create a promptflow, and then add it as only one node to the project? Similar to how functions in programming work so we don't have to repeat code.
Maybe code a tool for that?

Thanks

[brynn-code]

Hi @ArmykOliva , firstly wanna confirm with you, does the requirements is merge the above 6 nodes to 1 python nodes? aka you don't need to see the logic structure from the flow graph.
If so, you could do the 2 llm call and condition in to 1 python node, which means to call the llm in python instead of using the llm node directly. Our llm node call Azure OpenAI/OpenAI where the code in promptflow-tools, which you could refer to here: https://github.com/microsoft/promptflow/tree/main/src/promptflow-tools/promptflow/tools

[ArmykOliva]

Hi, yes my idea would be to have one node, where I would define two prompts, one for checking whether edits need to be done and the other prompt to make the edit. Basically to save some output tokens and time, I just want to first check if I need to do some changes with the LLM at all. If no changes are done, just return the original input, if changes were done, return the edited LLM output.

If I were to just create a python function for this, how would you pass the required prompts to the node? And how would you make it still compatible with the dynamic setting of custom connection and LLM want in the DAG editor?

Also, what if it wasn't a simple if/else but rather a large switch?

[brynn-code]

Hi, I just write a dummy example for your case. The graph may have below structure:

With 'determine_prompt' and 'edit_prompt' as two prompt node which stores your prompts and give them as inputs to the python node, then a mock 'previous node' which give the original inputs to the python node, we will try to execute llm call twice in the python node and give the edited/not edited output.
The python node may looks like below:

from promptflow import tool
from promptflow.connections import AzureOpenAIConnection
from promptflow.tools.aoai import chat as aoai_chat

import os

# The inputs section will change based on the arguments of the tool function, after you save the code
# Adding type to arguments and return value will help the system show the types properly
# Please update the function name/signature per need
@tool
def my_python_tool(determine_prompt: str, edit_prompt: str, original_input: str, connection: AzureOpenAIConnection, deployment: str) -> str:
    result = aoai_chat(
                    connection=connection,
                    prompt=determine_prompt,
                    deployment_name=deployment
            )
    if needs_editing(result):
        result = aoai_chat(
                    connection=connection,
                    prompt=edit_prompt,
                    deployment_name=deployment
            )
        return result
    return result


def needs_editing(result):
    # Put your own logic here
    return "Yes" in result

With two prompt inputs, your original inputs, the connection you need (I'm using AzureOpenAIConnection here, if you need custom connection, then just change the annotation to CustomConnection and generate tool meta again), and a deployment represent any other llm settings you may need for llm call.
Then you could choose to return the original input directly, or return the edited result based on your own logic.