The introduction of AI assistants in Flare V11 reflects a broader objective: to streamline routine molecular modelling tasks, reduce efforts required to locate and interpret documentation, support more consistent workflows across teams, and enable users to generate bespoke, high-quality PyFlare code even if they have limited programming experience. Whether you are new to Flare or an experienced PyFlare developer, adopting clear prompting habits improves the relevance, correctness, and reproducibility of the outputs.

AI-enabled assistants are now integrated into Flare to augment both the graphical user interface (GUI) and the Flare Python API. Two complementary models are available within the assistant:

1. The Chat Model employs retrieval over current Flare documentation to provide real-time guidance on software capabilities, configuration options, and recommended practices.
2. The Code Model targets development workflows, generating executable PyFlare examples, clarifying code behaviour, and suggesting implementation patterns that support reproducibility and maintainability. This article outlines best practices for effective use of these assistants.

Because the system relies on retrieval-grounded responses and generated code suggestions, its accuracy and usefulness depend heavily on how users structure their queries.

The best practices outlined below are informed by internal testing, user feedback and observed interaction patterns when working with retrieval-augmented LLM systems.

The Chat Model leverages up-to-date Flare documentation to resolve queries related to functions exposed via the GUI. While Flare is designed for straightforward operation within its supported calculation space, the AI Assistant provides additional information by returning direct citations and links to the most relevant documentation sections. This linkage enables rapid verification of details such as parameter definitions, default settings, scope of applicability, and academic references without manual navigation of the full documentation (see Figure 2).

The Code Model is designed to generate executable PyFlare scripts, provide code-level explanations and improve developer productivity across typical cheminformatics workflows. A central objective is to enable low-code/no-code interactions, thereby broadening access to Flare Python API for users with diverse programming backgrounds. As with any AI-assisted system, effectiveness depends on well-formed queries and careful review of outputs. The guidelines below summarize recommended practices.

1) Specify the task precisely

Clearly define the objective when you draft a query. Precise questions improve retrieval quality and, in turn, the correctness of generated code.

Example query for conformation hunt / conformer search in PyFlare:

“Could you provide a detailed guide on how to set up and execute a conformation hunt, including any necessary code snippets. Additionally, please explain how to handle ligands with existing conformations and how to check the results of the conformation hunt.”

This formulation of the query (i) names the task unambiguously, (ii) requests runnable code, and (iii) anticipates edge cases (pre-existing conformations) and validation, which collectively leads to a more comprehensive response.

2) Define the execution scope

Flare Python API can operate inside the Flare GUI (acting on the current project) or as a standalone script outside Flare. State which context you need:

• In-project (Flare Python interpreter):
  • “How can I prepare the first protein in my Flare project at pH = 8.0?”
• Standalone script (local filesystem):
  • “Write a script that prepares the protein in proteins.pdb at pH = 8.0.”

Both requests concern protein preparation at a specified pH, but they require different runtimes, inputs, and I/O patterns. Being explicit avoids mismatched answers.

3) Prefer small, single-purpose queries

The assistant retrieves a fixed number of documentation chunks. Broad, multi-step prompts dilute retrieval and increase error risk. Break complex workflows into focused sub-questions.

Example of a less effective (too broad) query:

“Write a script that prepares the protein in the ‘Proteins’ role named XXXX, then dock all ligands into it at the lowest quality.”

This may yield a partial script for selecting and preparing the protein, setting up the docking experiment, however, it could fail to infer what “lowest quality” means for docking in Flare.

A better approach would be to decompose the query into more focused tasks:

• “How to set the quality of docking in PyFlare?”
• “Write a script that prepares the protein in the ‘Proteins’ role named XXXX, then dock all ligands into it at the VirtualScreening quality” – using information from the response of the first query (Figure 4)

4) Review and iterate on generated code

Treat AI-generated code as a starting point, especially when it modifies a live Flare project. Review imports, parameter values, convergence/threshold settings, and side-effects. When possible, test on small, non-sensitive inputs or in a sandbox first.

However, even AI-generated code with mistakes can still be productive if you iterate:

Example (counting nitrogen atoms in ligands):

• Initial query: “Please count the number of nitrogens in each ligand, and add this number to a new column in the ligands table with the title “num_nitrogens”.
• Possible outcome (Figure 5): the assistant creates the column correctly but returns zeros for all rows – indicating an incorrect atom filter.
• Follow-up query: “How to check if an atom in the ligand is N in PyFlare?”
• Likely correction: use atom.atomic_number (rather than atom.element) to identify element N. Substituting the correct check into the earlier snippet yields the expected counts (Figure 6).

5) Protect data privacy and IP

Although Flare’s assistants do not store user chat history or personal information, treat all chemistry data as sensitive. Avoid pasting:

• Real chemical structures or IDs (SMILES, InChI, registry numbers).
• Proprietary project names, sample IDs, or experimental conditions.

Finally, safeguard your data by using placeholders and synthetic examples instead (e.g., CCO → MOLECULE_A). If you must share structures for debugging, prefer public or toy molecules (e.g., ethanol, benzene).
In summary, the most effective use of Flare’s AI assistants is disciplined and deliberate: check answer and citations for further information, state a single, well-defined task, declare the execution scope (Flare GUI vs. standalone script), and decompose multi-step workflows into focused queries to respect retrieval limits.

Treat generated code as a starting point, review parameters and options, and iterate with targeted follow-ups when something appears incorrect. Finally, safeguard your data by using placeholders for molecules and metadata. This approach yields faster, more reliable answers and reproducible PyFlare workflows.

Flare’s AI assistants substantially enhance the accessibility and speed of everyday modelling workflows, but the quality of their outputs improves when paired with deliberate prompting and careful code review. As with any computational method, rigorous verification against documentation and experimental context remains essential. Proficiency with the AI assistants grows through iteration: refining queries, testing small components, and incorporating feedback. Over time, this practice leads not only to faster task execution but also to deeper familiarity with the Flare platform and more scientifically robust modelling outcomes.