Skip to main content

Using Azure AI for Entity Creation

  • Updated
  • Reading time: —

Article last updated on the 16th of December, 2025.

Contents

1. Introduction

2. Requirements

3. Deploying an AI Model

4. Setting up a HTTP endpoint

5. Setting up a Graph endpoint to extract e-mail content

 5.1. Setting up a credential

 5.2. Setting up Graph endpoint

6. Setting Up Entity Creation Process

7. Running the Process

8. Extension possibilities

 8.1. Setting the Customer field automatically based on e-mail sender

 8.2. Creating tasks suggested by AI

 8.3. Send an e-mail reply suggested by AI

1. Introduction

In this article, we will demonstrate how you can leverage artificial intelligence functionality in Azure when creating entities such as cases, contracts, or projects in WorkPoint 365.

For demonstration, we will use artificial intelligence in a process to extract case information from an incoming e-mail, and use it to fill an Entity form in WorkPoint Automate so we can create a new case in the system.

For this purpose, we will go through the following steps:

  • Set up an Azure AI Foundry resource and deploy an AI model.
  • Set up a couple of HTTP endpoints in WorkPoint.
  • Set up a WorkPoint Automate process to call the HTTP endpoint and create a new case.

2. Requirements

Following the steps in this article requires that you have already set up the following:

  • An Azure subscription: An Azure subscription is the foundational billing and access boundary in Microsoft Azure.
  • A resource group: A resource group is a logical container within a subscription that holds related Azure resources like virtual machines, databases, and importantly, AI services.
  • An Azure AI Foundry resource: The primary Azure resource type for building, deploying, and managing generative AI models and applications including agents in Azure. You can read about how to set up an Azure AI Foundry resource here.

3. Deploying an AI Model

Before we can use Azure AI in WorkPoint 365 to help us create entities, items, and do other actions, we need to deploy an AI model to our Azure AI Foundry resource.

Assuming you already set up an Azure AI Foundry resource, you can deploy an AI model to the resource by navigating to https://ai.azure.com/resource.

This should open a page similar to the following:

  1. In the left side menu, under "My assets", click "Models + endpoints" (This may also be called "Deployments" and live under a section called "Shared resources").
  1. On the Model deployments page, click "Deploy model" and select "Deploy base model".

This opens the following dialogue:

Here we need to select an AI model of type "Chat completion", because we eventually want to give the AI model a prompt, and have it respond with some message containing data of some sort.

It is important to consider which model to deploy and use, because they may vary greatly in cost of tokens per API call. If you need it to process simple data, and give relatively simple responses, as we do in this example, you should select a fairly inexpensive, simple AI model.

In this instance, we will select the gpt-5-mini model:

  1. We search for and select the gpt-5-mini model.
  2. We then click the "Confirm" button.
  1. In this case we keep the automatically generated name for the deployment, and select the "Standard" deployment type. You can read more about the different deployment types by selecting them, and clicking the links in their individual descriptions.
  2. We then click the "Deploy" button.

Once the model is deployed, you should see it listed in the Model deployments page:

  1. To view more information about the deployment, it's endpoint and it's API key, we click the title.

This should open a page similar to the following:

In the "Endpoint" section of the page in the previous screenshot, we can find information that we need in order to use this model deployment in WorkPoint 365. When we set up a HTTP endpoint in WorkPoint, we need the target URI and the Key to be able to call this AI deployment model and provide us with a response.

In the next section, we will set up the HTTP endpoint in WorkPoint.

4. Setting up a HTTP endpoint

In this section, we will set up a HTTP endpoint inside WorkPoint to send a request to the previously configured AI deployment, and get a response back. We will then explore how we can use this setup for entity creation in WorkPoint 365.

In this section, we are going to need the target URI and the Api Key for the deployment, which we found in the previous section.

We then begin on the HTTP endpoint library page in the WorkPoint administration:

  1. In the HTTP endpoint library, we click the "Add" button to set up a new endpoint.
  1. In the Title, we provide the name of the AI model deployed. You should name the endpoint something informative in line with what you intend to use it for, for example "Get project data from e-mail" or similar.
  2. We have created a parameter called "messageData". This will allow us to send data from e.g., a WorkPoint Automate step to the AI model through this parameter on a Send Http Request step. Eventually, this is also where we will input the e-mail data that the AI should create entity data from - more on that later.
  3. In the "Url" field, we have pasted the target URI of our deployed AI model.
  4. In the "Http(s) endpoint action" field, we have selected "Post", as we will send a request body containing our prompt to the AI model.
  5. In the Header section, we have set up standard Accept and Content-type headers, as well as the "Api-Key" header, containing the Key found on the AI model deployment page shown in the previous section.

Next, we need to define the prompt we want to send to the AI model in the Body section.

If we look at the AI model deployment page, a couple of examples of how to call it's endpoint are given:

  1. First, we switch the language to "REST".

In the "2. Run a basic code sample" section, we can now see the following example:

Unfortunately, Microsoft's example here relates to older AI models, but we can make a few tweaks so we can use them with the GPT 5 model we selected anyway:

From here, we can extract the JSON object containing the messages array, as well as various other properties:

{
	"messages": [
		{
			"role": "user",
			"content": "I am going to Paris, what should I see?"
		}
	],
	"max_completion_tokens": 16384,
	"model": "gpt-5-mini"
}
Click to copy

But instead of using the "messages" property, we rename it to "input", as that is required by the GPT 5 model. We also rename the "max_completion_tokens" property to "max_output_tokens" and set it to a higher number. Additionally, we add the "temperature" and "top_p" properties, and set them to 1. These will be explained later:

{
	"input": [
		{
			"role": "user",
			"content": "I am going to Paris, what should I see?"
		}
	],
	"max_output_tokens": 16384,
	"temperature": 1,
	"top_p": 1,
	"model": "gpt-5-mini"
}
Click to copy

In theory, this is all we need in our body in order to talk with our AI model from WorkPoint. with a minor modification:

  1. In the "Body" field for our HTTP endpoint configuration, we have now pasted the JSON object mentioned before, but instead of the hard-coded content string, we have instead created a reference up to our parameter value.

In the "Test Value" field of our parameter, we can now type a question, like so:

And clicking "Test" near the bottom of the page should result in an answer from our deployed AI model:

Copying this response into a text editor let's us more easily inspect the AI model's response in the "output[1].content[0].text" object:

Since we got a response back, we can also use the response to automatically generate a response schema for the endpoint:

  1. Clicking the "Autogenerate from test" button fills the Schema field.

Before we click the "Add" button to save the endpoint, we insert the following request body so that this endpoint eventually supports analyzing and returning case information from the e-mail we are going to provide it:

{
	"input": [
		{
			"role": "system",
			"content": "You are an AI assistant that extracts unstructured case information from an email message (provided as a JSON document from the Microsoft Graph Messages endpoint) formatted in HTML. You must strip the body from HTML and analyze the body content.\n\nYour job is to read the email text and return **only** a JSON object containing two top-level properties: `Case` and `SuggestedReply`. Do not include any other properties or text outside the JSON.\n\n### CASE INFORMATION (inside the `Case` object):\n- `Title`: A short descriptive title summarizing the main purpose of the email.\n- `ccCaseType`: One of `Standard`, `Purchase`, `Complaint`, or `Service & Repair`. Choose the most appropriate type.\n- `wpStartDate`: The current UTC date formatted as `MM/DD/YYYY`.\n- `wpDueDate`: The date **14 days after** `wpStartDate`, formatted as `MM/DD/YYYY`.\n- `wpPriority`: One of `Low`, `Medium`, or `High` based on urgency or tone.\n- `wpRisk`: One of `Low`, `Medium`, or `High` based on the potential impact.\n- `wpBudget`: A suggested numeric budget amount appropriate for the situation.\n- `wpDepartment`: One of `Standard`, `Complaint`, `Purchase`, or `Service & Repair`. Choose the most appropriate department based on the content.\n- `wpDescription`: A concise summary of the email contents.\n\n### SUGGESTED REPLY (in `SuggestedReply`):\nWrite a polite, professional reply addressing the sender’s main concern.\nEnd the reply with:\n- “Best regards, [current user’s name]” if known, otherwise\n- “Best regards, The Northwind Team”.\n\n### OUTPUT FORMAT:\nReturn **only** a JSON object exactly in this structure:\n```\n{\n  \"Case\": {\n    \"Title\": \"\",\n    \"ccCaseType\": \"\",\n    \"wpStartDate\": \"\",\n    \"wpDueDate\": \"\",\n    \"wpPriority\": \"\",\n    \"wpRisk\": \"\",\n    \"wpBudget\": 0,\n    \"wpDepartment\": \"\",\n    \"wpDescription\": \"\"\n  },\n  \"SuggestedReply\": \"\"\n}\n```\n\nDo not include any explanations, comments, or extra fields. Only return this JSON object. Return the JSON object as raw JSON, not as a string. Do not escape characters like \\n or \\\\. Do not wrap the JSON in quotes."
		},
		{
			"role": "user",
			"content": "[messageData]"
		}
	],
	"max_output_tokens": 16384,
	"model": "gpt-5-mini"
}
Click to copy

In this request body we have defined a "system" message, which let's the AI model know what function it serves us, and what we expect it to do, and importantly, what we need it to give us when presented with an e-mail. We also keep the "user" message as is, because this is still where we are going to eventually provide information from an e-mail for the AI to process.

The "temperature" property controls how creative the AI model's response will be. This value should be between 0.0 and 2.0. The lower the value, the more deterministic the response, i.e. less creative.

The "top_p" value controls nucleus sampling, which is another way to limit randomness. This value should be between 0.0 and 1.0.

You typically use either temperature or top_p, but not both.

Here, temperature: 0.7 and top_p: 0.95 together give balanced creativity and control.

The "max_output_tokens" value sets a limit on the number of tokens the model can generate in its response. A token equals roughly 4 characters of English text. You can use this property to prevent runaway or excessively long responses.

Obviously, if you need your AI model to generate different types of response information, or act in a different way to ours here, then you would need to tinker with the system prompt until the AI model behaves as you need it to.

Please be aware that if you deploy a different AI model, e.g., GPT-5-Mini, the syntax and contents of the Post body needs to b e adapted according to the examples given in the AI Model Deployment page.

  1. We can now save the HTTP endpoint by clicking the "Add" button.

5. Setting up a Graph endpoint to extract e-mail content

Next, we need to set up a Graph endpoint which can take an e-mail message ID and extract information from it. But before we do so, we need to set up a credential so that we can call the Graph in the first place:

5.1. Setting up a credential

  1. On the Http Endpoint Library page, in the Credentials section, click the "Add" button.
  1. We provide a fitting title for the credential, in this case "MSGraph".
  2. For Credential Type, we select "Azure AD User Delegated". This allows WorkPoint to act on behalf of the signed-in user to access Azure resources, using the user's identity and permissions. This is required for WorkPoint Automate to call a given Graph endpoint using the user's permissions to access various resources they have access to.
  3. In the Tenant field, we provide our Microsoft 365 Tenant ID. You can find yours by going to https://aad.portal.azure.com/.
  4. In the Scope field, we input "https://graph.microsoft.com/.default"
  5. We can now click the "Add" button to add this credential.
  1. If met by a confirmation dialogue, click the "Yes" button.

The new credential should now appear in the Http Endpoint Library:

Next, we can set up the Graph endpoint to extract e-mail information.

5.2. Setting up Graph endpoint

In this section, we will set up a Graph endpoint which, provided an e-mail ID, will extract information from it, for example the e-mail's sender, subject, body preview, etc. When calling this endpoint, the "Express" context object in WorkPoint Automate will provide the e-mail ID.

  1. On the Http Endpoint Library page, in the Http Endpoints section we click the "Add" button to add a new endpoint.
  1. In the "Title" field, we provide a fitting name, in this case "Read Email".
  2. Next, we add a parameter called "messageId". This is the parameter in which we will eventually pass the e-mail ID from the Express context object in WorkPoint Automate.
  3. In the "Url" field, we provide the following Graph endpoint URI: https://graph.microsoft.com/v1.0/me/messages/[messageId].
  4. In the "Http(s) endpoint action" field, we select "Get".
  5. In the "Query" section, we add a query with the "$select" key, and the following value: sender,sentDateTime,subject,hasAttachments,bodyPreview,receivedDateTime,toRecipients,body
  6. In the "Credentials" field, we select the credential we made in the previous section.

This will allow us to call the Graph and extract the information specified in our $select query.

To test this endpoint and auto-generate the return schema, we will create a simple 1-step user process in WorkPoint Automate which simply prints out the e-mail ID of a selected e-mail in Outlook to a text field on a Custom form:

  1. We create a user process and add a custom form step to it. We then add a text field to the form and expand the options. Then, we click the "Advanced" button for the Value field.
  1. We switch to Advanced mode and input the following adaptive expression:
string(Express[0].ItemId)
Click to copy
  1. We then save the process as draft.
  2. Finally, we publish the process so we can run it from Express365 in Outlook.

We then set up a My Tools button for Express365 to execute the process:

Don't forget to set "Display in app" to Express 365.

Inside Express365, we can then select an e-mail and run the process, which should give is the e-mail ID:

The e-mail ID is shown in the text field:

We can now try and copy this e-mail ID and paste it into the messageId parameter of our Read Email http endpoint:

Clicking the "Test" button near the end of the page should now show the information we requested in the $select query:

  1. To automatically generate the response schema for our endpoint, we click the "Autogenerate from test" button, which fills the Schema field:
  1. We can now click the Save or Add button to save our endpoint.

We now have everything we need to set up our entity creation process, so let's look at that next.

Note that if you, like we do in our example, request to have body extracted from the e-mail, you may run into issues where the Autogenerate schema from test doesn't work properly. This is due to the various HTML and quotation marks inside the body. In that case, you can manually add the body to the schema, like we have done here:

{
	"$schema": "http://json-schema.org/draft-04/schema#",
	"type": "object",
	"properties": {
		"@odata.context": {
			"type": "string"
		},
		"@odata.etag": {
			"type": "string"
		},
		"id": {
			"type": "string"
		},
		"receivedDateTime": {
			"type": "string"
		},
		"sentDateTime": {
			"type": "string"
		},
		"hasAttachments": {
			"type": "boolean"
		},
		"subject": {
			"type": "string"
		},
		"bodyPreview": {
			"type": "string"
		},
		"sender": {
			"$ref": "#/definitions/Sender"
		},
		"toRecipients": {
			"type": "array",
			"items": {
				"$ref": "#/definitions/ToRecipient"
			}
		},
		"body": {
			"$ref": "#/definitions/body"
		}
	},
	"definitions": {
		"Sender": {
			"type": "object",
			"properties": {
				"emailAddress": {
					"$ref": "#/definitions/EmailAddress"
				}
			}
		},
		"EmailAddress": {
			"type": "object",
			"properties": {
				"name": {
					"type": "string"
				},
				"address": {
					"type": "string"
				}
			}
		},
		"Anonymous3": {
			"type": "object",
			"properties": {
				"name": {
					"type": "string"
				},
				"address": {
					"type": "string"
				}
			}
		},
		"ToRecipient": {
			"type": "object",
			"properties": {
				"emailAddress": {
					"$ref": "#/definitions/Anonymous3"
				}
			}
		},
		"body": {
			"type": "object",
			"properties": {
				"content": {
					"type": "string"
				}
			}
		}
	}
}
Click to copy

6. Setting Up Entity Creation Process

In this section, we will use the two endpoint we created previously to automatically populate an Entity form with data based on an e-mail in Outlook.

The process will consist of the following steps:

  1. Send HTTP request: In this step, we use the Read Email http endpoint which, provided an e-mail ID, returns information from the e-mail. Specifically, we need the "body" information from the e-mail in the next step.
  2. Send HTTP request: In this step, we take the information from the e-mail body we got from the previous step, and let our Azure AI model analyze it and come up with a JSON object we can use as entity data (in this case, Case data).
  3. Entity form: In this form, we will present the data that the AI model reasoned would be fitting for the case we are about to create.
  4. Create entity: This step will create the case based on the data from the Entity form, i.e., the information that the AI model provided.

We start with an empty process which we have titled "Create case from e-mail":

Next, we add a Send HTTP request step:

Next, we give the step a fitting title, description, and name:

In the Options tab, we select the Read Email endpoint and provide the ItemId from the Express context object in the messageId parameter:

Next, we add another Send HTTP request step and give it a fitting title, description, and name:

In the Options tab, we select the gpt-35-turbo endpoint, and in the messageData parameter, we add the body.content object from the output of the ReadEmail step:

To test the process and see what the AI model actually produces for us at this point, let's try adding a custom form with a text field containing the output from the Analyze Email step:

In the Value field of the text field, we use the following adaptive expression:

string(AnalyzeEmail)
Click to copy

At this point, we can save and publish the process and try running it on a fitting e-mail from Express365.

Here we have selected an e-mail which holds information which could reasonably be construed as being related to a case. We have also set up a My Tools button to run the process we are working on, so let's try and run it:

Next, we copy the output from the text field and put it into a text editor for better inspection:

Copying out the output[1].content[0].text object gives us this JSON object from our AI model:

{
  "Case": {
    "Title": "Repair request for leased BX-5060 unit",
    "ccCaseType": "Service",
    "wpStartDate": "10/23/2025",
    "wpDueDate": "11/06/2025",
    "wpPriority": "High",
    "wpRisk": "Medium",
    "wpBudget": 250,
    "wpDepartment": "Service & Repair",
    "wpDescription": "Customer Anders Møker requests repair of a leased BX-5060 unit that is currently faulty. Customer prefers to return the unit for repair and have it sent back promptly. Repair is time-sensitive due to an upcoming convention in two weeks; requests next steps, forms, and shipping instructions."
  },
  "SuggestedReply": "Dear Anders,\n\nThank you for letting us know — I’m sorry to hear the BX-5060 is faulty. We will open a repair case and prioritize this due to your upcoming convention. To get started, please reply with the device serial number (or lease ID) and the shipping address you’d like us to use. Once we have that, we will issue an RMA, send you the return instructions and a prepaid shipping label (if applicable), and confirm an estimated turnaround time. We will expedite the repair and notify you as soon as the unit is dispatched back to you.\n\nIf you have any photos of the fault or error messages, please include them in your reply — they can help speed diagnosis.\n\nBest regards, The Northwind Team",
}
Click to copy

We can now use the Case object as step input for an Entity form, by proving the following into the Step Input:

[json(AnalyzeEmail.output[1].content[0].text).Case]
Click to copy

So now we add an Entity form to the process:

In the Step Input, we have provided the following:

In the Options tab, we hook the Entity form up to our Cases module:

In the Fields tab, we can now set the fields that the AI model does not automatically provide for us. For example, we can set the Case responsible to the current user:

Next, we can add a Create entity step, and feed it the output from the Case Information form as Step Input:

And in the Options tab, we set it up for our Cases module:

Next, for convenience, we go to the Process settings and enable the "Skip start step" option:

Finally, we can save and publish the process:

7. Running the Process

Now we can finally try and select a proper e-mail and run the process on it.

We have already tested with the following e-mail, so let's try it again:

  1. With the e-mail selected, we click our My Tools button to launch the process.

Once the Case information form is presented to us, we can see that the AI model has read our e-mail content, and suggests useful information, such as a title, a description, a case type, and other relevant case information. The information it doesn't automatically provide, we can fill ourselves:

  1. Next, we click the Continue button.

Our case is now being created:

After completion, we see our case has been created:

8. Extension possibilities

In this section, we will continuously introduce valuable extension opportunities to the processes outlined in this article. The goal is to regularly enhance the described functionality with meaningful and innovative additions.

8.1. Setting the Customer field automatically based on e-mail sender

In this article, we will evaluate the e-mail domain of the person who sent an e-mail and match it against customers registered in our Customers module in WorkPoint. If there is a match between the sender's e-mail domain, and the domain registered for a customer, the customer will automatically be set in the Case information form.

Link to article

8.2. Creating tasks suggested by AI

In this article, we extend both this current article, and the article in 8.1. to also create tasks suggested by the AI model on the newly created case.

Link to article

8.3. Send an e-mail reply suggested by AI

In this article, we will go through how to take the suggested reply from an AI model, and use it to send an e-mail response back to the original sender.

Link to article

Was this article helpful?
0 out of 0 found this helpful

Related articles

Comments

0 comments

Article is closed for comments.