Embedding Learnosity within an LTI Tool Provider

Example Company

A company, Oscorp, is an education company that does not currently have a custom built platform, but rather, has a prebuilt LMS.  Oscorp users- students and teachers alike- can log on to manage their classes, create and assign homework, or complete work given to them.

Oscorp’s Needs

Oscorp likes the LMS overall, and the company doesn’t want to move away from it.  They do not want to create a whole platform by themselves- they want to stay with their LMS.  But what they feel is lacking is the LMS’s default assessment tools.  They want to have more question types, more tools for their authors, and better analytics on how their students are answering questions.

Learnosity’s Solution

The Learnosity APIs can be embedded in an LTI wrapper- which allows the APIs to exist in an LMS without having to change the LMS’s underlying code.  This instance of the LTI wrapper can function for Authors and Students alike, and when a student completes their work, Learnosity can pass the grade back to the gradebook.

LTI Wrapper, which will contain:

  • The Author API
Embeds an Item editing tool within Oscorp's platform.

    • Gives their teachers the ability to author all of the different Learnosity Question types.
    • Gives their teachers access to Features, like video and audio players.

    • Allows Oscorp to limit the teachers to only see what they themselves have created, or allows
 them to select from Oscorp's entire Item bank.
Allows teachers to apply Tags to each Item, which can be used for sorting and reporting.

    • Saves all content to Learnosity’s servers.
The Items API
Embeds Items for students to answer directly within Oscorp's content.
    • Pulls down content from Oscorp’s Item bank, hosted on Learnosity’s servers.
Saves the student’s work, and submits it to the Learnosity servers for scoring.
The Reports API

    • Embeds reports designed for student and teachers within Oscorp’s platform.
Calculates what information to show and puts the UI (User Interface) on the page.

    • Can be called without UI for custom styled reports.

  • The Data API:
    • A server-to-server API which gives Oscorp access to all of their raw data


The LTI wrapper  or external tool  has to be built and managed by Oscorp.  The first thing they should do is look up the documentation in their LMS’s documentation to figure out exactly what they need to build.
But, put very simply, the end goal of any LTI Wrapper is to be a container where Oscorp can control the HTML within their LMS.  They want a place where they can embed the Learnosity APIs.


This middle layer  the piece that holds the Learnosity APIs and communicates with the LMS itself  has to be built by Oscorp.  This piece generally runs completely separately from the LMS itself, on a server controlled by them.
The LTI external tool has two important jobs, to begin with. First, security must be handled, ensuring both this LMS and this User is allowed to see Oscorp external tool.  It should be noted that this user’s identity should be saved  the API we choose to initialize, and what content the user should see, may depend very much on who they are and what their role is.
Once all this is confirmed, the External Tool can build the environment to be shown to the user.
First, let’s look at an example when the user is an Author.

Let’s split apart Figure 1 to see exactly what information is being passed where:
So, the LMS passes the user info into the Oscorp LTI environment.  The LTI environment then needs to understand, from this information, exactly what the user should see.  As the simplest example, it should be able to say whether or not this user is an author (and therefore that they should see the Author API and be able to edit).
This may go even further, however  the particular user may only be able to edit content (not author anything new), or only be able to see content with a particular tag, as two examples.  It’s up to the LTI environment to understand the requirements, and then, build the Init options from them.
Once they have been built, the rest is fairly simple: you initialize the Author API like you would in any other scenario.  The UI is handled by Learnosity  and as any Item an author saves Item content, the information is stored on Learnosity’s side:


Now let's take a look at the experience from the student’s side.  Our author has created content that’s ready for the student’s use.  So when the student accesses the external tool via the LMS, instead of initializing the Author API, the LTI environment knows to initialize the Items API  the API that’s meant for rendering Items to be completed by end users.  

An important step here is to initialize the Items API with information to pass the results back to the platform via LTI grade passback.  Learnosity can pass basic information automatically this way.

Once a student has completed their work, Oscorp has plenty of data to work with, all captured by Learnosity.  At this time, the score that the student earned is automatically passed back to the grade book, as they've defined where it should go on initialization.  But visually, the first thing they’d like to do is show a student an immediate summary of their work.  This can be done by initializing the Reports API.
The Reports API is going to build pre-made reports based on that student session and render them into the LTI environment, just like the other APIs are rendered.  This does not need to be a separate LTI tool or a different session than the instance of the student actually completing the work  since scoring happens so fast, we can simply render the responses right after the student completes their work.
This is the route Oscorp decides to go, immediately rendering a report after the student’s completed work:

With this, Oscorp has been able to render all three of the main Learnosity APIs - the Author API, the Items API, and the Reports API, without having to edit their LMS.  They simply served up the classic Learnosity experience using the APIs within LTI.
But Oscorp has deeper analytics requirements- they want to analyze the data in a custom way that is unique to their company.  They want to access the raw data behind the scenes, rather than the pre-built reports on the front end.
This is what the Data API is for.  Oscorp can pull the raw data, analyze it as they’d like, and finally, push the information they’d like over to the LMS’s grade book.

As well as using the Data API, an integrator can pass required information to Learnosity (by pre-setting an LTI consumer key and secret, also shared with the LTI Tool Consumer, in Learnosity Console), and when initializing the Items API, passing along the LTI grade passback URL and identifiers. In this case, when Learnosity has finished scoring a student test, we can provide raw, single grade passback directly to the LMS.

As a simple example, they may pull out all the response data for the students who took the Activity.  Or, they may only need the score, rather than all the details of the response.  Either way, they’re able to store both the custom info they need and put the basic info that they’d like into the LMS’s grade book.

Was this article helpful?

Did you arrive here by accident? If so, learn more about Learnosity.