Prompt Engineering 101: Optimizing 'Generate Response from Model' in FileMaker

The introduction of the Generate Response from Model script step in Claris FileMaker marks a pivotal shift in how we build custom applications. However, accessing a Large Language Model (LLM) is only half the battle. The other half—and the part that determines the stability of your application—is Prompt Engineering.

Many developers initially treat the Generate Response from Model step like a chatbot, sending loose instructions like "Summarize this email." While this works for casual interaction, it fails in a production environment where you need structured data, consistent formatting, and predictable logic.

In this article, we will explore how to transition from "asking" the AI to "programming" it via prompts, ensuring your FileMaker solution receives clean, actionable data every time.

The Architectural Shift: Natural Language as Code

When integrating AI into a database schema, we are rarely looking for conversational prose. We typically need the AI to perform a transformation: turning unstructured text into structured fields (JSON), analyzing sentiment (Boolean/Number), or translating content (Text).

To achieve this, we must view the Prompt not as a question, but as a function call. It needs a defined input, specific processing instructions, and a strict output format.

Core Principles of Robust Prompting

To optimize Generate Response from Model, adhere to these three architectural principles.

1. Assign a Persona (Role Prompting)

LLMs are trained on vast amounts of general data. Without specific direction, they default to a helpful, conversational tone. For data processing, this is noise. You must constrain the model's behavior by assigning it a specific role.

Weak Prompt:

"Read this invoice and tell me who the vendor is and the total amount."

Optimized Prompt:

"You are a rigorous Data Extraction Engine. Your sole purpose is to extract metadata from OCR text. You do not converse or explain your reasoning."

2. Enforce Output Structure (JSON Mode)

FileMaker thrives on structured data. Text blocks are difficult to parse; JSON is native. You must explicitly instruct the model to return JSON and—crucially—define the schema you expect.

The Schema Definition Pattern: Always provide a template of the JSON keys you require. This reduces hallucinations where the model might use "total_cost" one time and "invoice_total" the next.

3. Use Delimiters for Data Separation

When injecting dynamic data from your FileMaker records into a prompt, you must clearly separate the instruction from the data. If a user enters instructions into a notes field you are processing, the AI might get confused (a vulnerability known as Prompt Injection).

Use delimiters like triple quotes (""") or XML-style tags (<input>) to sandbox the data.

Implementation: Building a Data Cleaning Script

Let’s look at a practical example. We have a Leads table with a RawContactInfo text field containing messy copy-pasted signatures. We want to extract the Name, Email, and Phone number into clean fields.

Step 1: Constructing the System Prompt

First, we define the rules. We will construct this in a Set Variable step to keep the script readable.

Set Variable [ $JSON_TEMPLATE ; Value: JSONSetElement ( "{}" ;
  [ "full_name" ; "" ; JSONString ] ;
  [ "email_address" ; "" ; JSONString ] ;
  [ "phone_number" ; "" ; JSONString ]
) ]

Set Variable [ $SYSTEM_PROMPT ; Value:
  List (
    "You are a Contact Data Parser." ;
    "Task: Extract contact details from the provided text." ;
    "Output Rules:" ;
    "1. Return ONLY valid JSON." ;
    "2. Use this schema: " & $JSON_TEMPLATE ;
    "3. If a field is missing, use null." ;
    "4. Do not include markdown formatting (like ```json)."
  )
]

Step 2: Constructing the User Prompt

Next, we wrap the specific record data in delimiters.

Set Variable [ $DATA_INPUT ; Value: Leads::RawContactInfo ]
Set Variable [ $FINAL_PROMPT ; Value:
  List (
    $SYSTEM_PROMPT ;
    "--- BEGIN INPUT ---" ;
    $DATA_INPUT ;
    "--- END INPUT ---"
  )
]

Step 3: Executing the Script Step

Now we call the model. Note that we are handling the response assuming it might still contain some whitespace or unexpected characters, though our prompt tries to prevent it.

Generate Response from Model [
  Configuration: "OpenAI GPT-4o" ;
  Prompt: $FINAL_PROMPT ;
  Target: $response
]

# Error Handling and Parsing
If [ Get ( LastError ) = 0 ]
  # In FileMaker 2025, we can use JSONParse to ensure validity
  Set Variable [ $json ; Value: JSONParse ( $response ) ]

  If [ JSONGetElement ( $json ; "error" ) = "" ]
    Set Field [ Leads::Name ; JSONGetElement ( $json ; "full_name" ) ]
    Set Field [ Leads::Email ; JSONGetElement ( $json ; "email_address" ) ]
    Set Field [ Leads::Phone ; JSONGetElement ( $json ; "phone_number" ) ]
  End If
End If

Advanced Technique: Few-Shot Prompting

If the model struggles with specific edge cases (e.g., distinguishing between a direct line and a mobile number), use Few-Shot Prompting. This involves providing examples of "Input -> Correct Output" inside your prompt before asking it to process the live data.

Adding just two examples to your prompt significantly increases the model's accuracy because it can pattern-match the logic rather than just interpreting the instructions.

Trade-offs: Context Window and Cost

While detailed prompts ensure accuracy, they consume tokens. Every character in your system prompt, JSON template, and few-shot examples counts toward your API cost and context limits.

Latency: Longer prompts take longer to process. For real-time user interactions, keep instructions concise.
Cost: If you are processing 10,000 records in a loop, a verbose prompt will multiply your costs. In batch processing scenarios, spend time refining your prompt to be as short as possible while maintaining reliability. Research and determine which model will best suit your needs. If you are parsing data, you don't need the expensive "thinking" model. Opt for the "lite" or "fast" model that has lower cost but can achieve the same goal.

Conclusion

Prompt Engineering in FileMaker is about establishing a rigorous contract between your data and the AI model. By using delimiters, enforcing JSON schemas, and assigning strict personas, you turn the Generate Response from Model script step into a deterministic, reliable tool for your architecture.

Treat your prompts with the same care as your calculation formulas, and your AI integrations will be robust enough for mission-critical workflows.