Is there a way of using variabes in prompt retievers or agent system messages?

[BadlyDrawnBoy]

Hi,

I like to add for an example a user name to a prompt by using a global variable or letting other prompted experts know about the chat-history - is there a way of using variables in prompt retrievers or system messages of agents? At the moment I get a "variable 'User' not known" if I give it a try..

Thanks!

Martin

[BadlyDrawnBoy]

(Edit: Naa, did not asked it to use the docs, the attached conversation seems to be more grounded in facts!?) Just for kicks I let my Flowise Dev Mrs. Acid Burn answer the question - please rate it! ;)

Mrs. Burn:
Incorporating variables like a username into prompt retrievers or managing 'system messages' between different agents within Flowise to maintain context or chat history requires a nuanced approach. While Flowise does not inherently support global variables across different agent sessions in the traditional programming sense, there are strategies you can employ to simulate a shared context or pass variables effectively. Here's how you can approach this:

Using Context or Metadata

1. Session-based Context Management: For each user session, maintain a context object that stores variables such as the username, and pass this object as part of the prompt or in the metadata when making calls to other agents or processes. This requires careful management of session states and variables but can effectively pass information like a username between different components.
2. Database or State Management: Implement a database or a state management solution where you can store user-specific or session-specific data. Before making a call to another agent or executing a function that requires this data, you can retrieve it from the database. This approach is more scalable and allows for complex data management strategies across different sessions and agents.

Implementing with Flowise

While directly using variables like you described might not work out of the box due to the current limitations, here's a conceptual approach to achieve similar functionality within Flowise:

1. For Static Variables: If the username or any other variable is static or known ahead of time for a given session, you can manually insert these variables into your prompt or system message as part of the input. This involves manually adjusting your prompt to include the necessary context.
2. For Dynamic Interaction:
   • Pre-Session Setup: If possible, have a pre-session setup where the user provides their username or other necessary information. This information is then stored either in a temporary session context or passed along with each request.
   • Custom Agent or Process Handling: Develop a custom agent or process within Flowise that is responsible for handling the context management. This agent could be designed to fetch and pass variables like usernames by incorporating them into the prompts or system messages based on the stored context or database entries.
3. Using Flowise Tools for Context Passing:
   • If you're looking to pass variables between prompts or agents within a single session, consider using the metadata fields or session identifiers (if available) to store and retrieve necessary information.
   • For more complex scenarios, such as querying a database or an external API to retrieve user data based on session identifiers, you can use Flowise’s functions.requests_get or functions.requests_post tools to dynamically fetch and insert these variables into your prompts or system messages.

Practical Example:

Assuming you want to pass a username to a prompt dynamically, you might consider setting up an external API or a database call that retrieves the username based on a session ID or other identifiers. Then, use functions.requests_get or functions.requests_post to fetch the username right before you make the call that needs this information, inserting it into the prompt or metadata dynamically.

This approach requires some setup outside the immediate Flowise tooling (like an external database or API) but allows you to dynamically manage and pass variables between different components of your Flowise setup.

Remember, the specific implementation details will depend on your exact requirements and the capabilities of the Flowise platform at the time of your project. Always refer to the latest Flowise documentation for the most current features and functionalities to support your use case.

Me:
What confuses me is that some prompt nodes are available that allow users to inject variables, and others do not offer this possibility, or in the case of the agent nodes, do not allow an external prompt at all.

Mrs Burn:
The variability in how different nodes within Flowise handle variables, especially between prompt nodes and agent nodes, can indeed be a source of confusion. Let's clarify the distinction and explore how you might work within these constraints to achieve your goals.

Prompt Nodes vs. Agent Nodes

• Prompt Nodes: These nodes are designed to execute specific tasks or functions, often allowing for more flexibility in configuring inputs, including the ability to inject variables directly into the prompt. This flexibility makes it easier to dynamically customize the behavior of these nodes based on the context or specific requirements of a session.

• Agent Nodes: Agent nodes, on the other hand, are generally more rigid in their configuration. They're designed to encapsulate a broader set of functionalities or workflows, often without the direct ability to modify their prompts dynamically through external variables. This design choice is typically meant to streamline the agent's operation and ensure consistency in its execution but can limit flexibility in certain scenarios.

Workarounds and Strategies

Given these constraints, here are some strategies to work around the limitations and still achieve a level of dynamic interaction and context passing:

1. Preprocessing Steps: For agent nodes that don't allow external prompt configuration, consider implementing a preprocessing step using a prompt node that does allow for variable injection. This step can prepare and format the necessary input, including any dynamic variables, before passing it to the agent node.

2. Custom Agents or Wrappers: If possible, create custom agents or wrapper functions that internally manage the dynamic aspects of your workflow, including variable injections. These custom components can be designed to accept external inputs as part of their initial configuration, allowing you to maintain flexibility in how you pass and manage context.

3. Using Metadata or Context Objects: Where direct prompt modification isn't possible, leverage metadata or context objects to pass along necessary information. While this may not directly inject variables into the prompt, it allows the receiving node to access and utilize this information in its processing, assuming it's designed to do so.

4. Feedback Loop: Implement a feedback loop where the output of an agent node can be analyzed or modified by a subsequent prompt node, allowing for dynamic adjustments based on the results. This might involve extracting relevant information from the agent's output and using it to modify the input for the next step in the workflow.

5. Consolidation of Functionality: Where feasible, consolidate the functionality that requires dynamic variable injection into nodes that support it, reducing the need to pass these variables into more rigid agent nodes.

Practical Consideration

When designing your flows, consider the limitations and capabilities of each node type. Planning your flow architecture around these constraints can often provide a pathway to achieve the desired outcomes, even if it requires a more creative approach to workflow design.

It's also worth staying updated with Flowise's platform developments. New features and enhancements are regularly added, which might offer more elegant solutions to these challenges over time.

If you're encountering specific limitations with the current set of tools and nodes available in Flowise, providing feedback to the development team can also help guide future updates to better accommodate these use case

[acdewinter]

So if you're completely contained in Flowise and don't have an external app interacting with it, then stuff becomes more tricky. However I wanted to pass in customer system prompts + userid of the user that is using the bot and that was definitely possible.

If you make a static variable and set the value to null (in this case username), you can push a dynamic value into it using the overrideConfig options when you embed your bot/call the api (you can do it on both).

You can also use the overrideConfig to change the values of inputs in a node (so in turn the system prompt etc).

Leon van Zyl on YouTube has a nice tutorial video in how to use override config, and it is somewhat covered in the docs as well.

So what it comes down to is you need some backend that retrieves data, and dynamically pushes this to the agent through the API or Embed using the custom config settings.

Eg setup would be for username:

FlaskApp + Google Auth + some DB + flowise embed.

User Auths through Google and is directed to the landing page where the bot is embedded

Your FlaskApp retrieves that and passes it along to the front-end route (landing page) in a javascript variable

Your embedded override config sets the Flowise static variable = to the passed on username from your app.

You also specify the system prompt in the override config to be "You are a helpful assistant blah blah blah.... " + username + " continue message here"

Now you have the users name in the prompt (or whatever other variables you are wanting to pass in there), and you can also use the username variable in other custom tools.

NB: What I have not tested yet, is what happens to the variable when multiple users are hitting the workflow at the same time, I don't know if it instances it for each user or if the next subsequent user authing in will override it for everyone. If that is the case then this solution is pointless.

[BadlyDrawnBoy]

Flowise_Variables.pdf