Skip to content

AcademIA Content

AcademIA Content brings AcademIA’s Creator Studio, where courses are built, into the flow. With a single component you work with learning paths (courses) and their translations: you can create a path, add its whole syllabus with its lessons in one go, publish it and translate it to other languages.

It is useful to produce courses automatically, for example from a document that an AI model turns into a syllabus.

When to use it

  • You have a PDF manual and want to turn it into a course: an AI model writes the modules and lessons, and the flow creates the path in AcademIA.
  • You want to publish a path or take it out of the catalogue from an automation.
  • You need to translate a course into English, Portuguese or another language and follow how the translation is going.
  • A content assistant must be able to list the courses, read one or start its translation when asked.
  • You want an agent to act as the course mentor: answering the student’s questions with the lesson they are looking at and the rest of the course.

Configuration

You need an AcademIA credential with two details: AcademIA API address, the AcademIA API address (for example https://academia.nappai.es/api), and API key, an AcademIA API key (it starts with nappai_int_sk_live_). NappAI doesn’t ask for the email or password of any AcademIA account. See Credentials.

An AcademIA administrator creates the key with New key:

  • A Super admin, in Platform › API keys. In Acts as, choose the role the key works with (and its organisation or faculty, if the role needs one). For the voice evaluator and the course mentor, also tick Voice and mentor sessions.
  • A Corporate admin, in Advanced › API keys. That key acts as their company’s administrator and only sees their organisation.

AcademIA shows the key only once: copy it when you create it and paste it into API key. If someone revokes it in AcademIA, the flow stops getting in straight away and you need to create another one.

For this component, the key must act as a Content admin (CONTENT_ADMIN), a Faculty admin (FACULTY_ADMIN) or a Super admin (SUPER_ADMIN). A Content admin key only sees and edits its own paths: those they created, those where they are an instructor, or those of their faculty.

FieldWhat it does
Credential (required)The AcademIA credential. It fills in AcademIA API address and AcademIA API key for you.
ResourceWhat you work with: Paths, Quizzes, Voice Sessions, Mentor Sessions (the course mentor’s sessions) or Translations. Default: Paths.
OperationWhat you do. The list changes with the chosen Resource. See Resources and operations.

When you choose the resource and the operation, the component shows only the fields that operation needs.

Resources and operations

Paths (learning paths)

OperationWhat it doesFields
List PathsReturns the paths the key can edit, with their publication status, modules and enrollments.Optional: Enrollment mode (Any, OPEN or INVITATION_ONLY).
Get PathReturns one path with its settings and modules.Path ID
Create PathCreates a new, unpublished path.Title, Description. Optional: Slug, Access, Language, Enrollment mode, Difficulty and Estimated hours.
Import CurriculumAdds modules and lessons at the end of a path, unpublished.Path ID, Modules (JSON). Optional: AI task ID.
Publish PathPublishes a path or takes it out of the catalogue.Path ID, Published (on publishes it; off takes it out).

The fields of Create Path:

  • Slug is the path’s name in its web address: letters, digits and dashes. If you leave it empty, it is made from the title.
  • Access says who can take it: FREE_REGISTERED (any registered person, the default), PUBLIC, PAID_STARTER, PAID_PRO, PAID_ELITE or CORPORATE.
  • Language is the language the content is written in: es (default), en, pt-BR, fr, it, de or ca-ES-valencia.
  • Enrollment mode: OPEN (anyone can enroll, default) or INVITATION_ONLY (by invitation only).
  • Difficulty is free text, for example Principiante, Intermedio or Avanzado. Default: Principiante.
  • Estimated hours is the estimated number of hours, for example 6 or 2.5.

Modules (JSON) carries the list of modules, each with its title and its lessons. Each lesson’s content goes in contentMd, in Markdown format:

[
{
"title": "Introduction",
"description": "What you will learn in this course",
"lessons": [
{ "title": "Welcome", "contentMd": "## Hello\nIn this course…", "estimatedMinutes": 10 }
]
}
]

Each module and each lesson need a title. AI task ID is optional: if the syllabus comes from an AcademIA AI task (see AcademIA AI Tasks), enter its ID and AcademIA marks it as accepted.

Quizzes (quizzes with the teacher’s criteria)

OperationWhat it doesFields
List QuizzesLists the quizzes you can edit, with their module, their path and how many questions they have.
Get QuizReturns a quiz with its questions and the teacher’s grading criteria.Quiz ID
Get Module QuizThe same, from the module it belongs to.Module ID

They return the quiz the way an evaluator needs it: title, passing score (70 by default) and each question with its id, type, text and criteria. This is how an evaluator agent, a voice agent included, reads the topic it must assess straight from AcademIA: connect it as a tool of the agent with a fixed id. It needs a key that acts as a Content admin, Faculty admin or Super admin (CONTENT_ADMIN, FACULTY_ADMIN or SUPER_ADMIN).

Voice Sessions (voice evaluation started from AcademIA)

When a student picks the voice mode of a conversational quiz, AcademIA opens a voice session (it knows which student and which quiz) and calls the published voice agent. The call carries academia_session:<id> in its context; with these two operations the agent redeems that id and sends the result back.

OperationWhat it doesFields
Get Voice SessionReturns the student (name, first_name), the course (course) and the quiz with its questions and criteria, in the same shape as Get Quiz. An expired, already graded or unknown session fails with its reason.Session ID (with or without the academia_session: prefix).
Submit Voice ResultSends a 0–100 score for each question. AcademIA works out the final grade (rounded mean) and the pass with the quiz’s passing score, records the attempt, notifies the student and puts it in the teacher’s review queue. Returns score, passed and passing_score.Session ID, Result (JSON).

Result (JSON) has one answer per question:

{
"answers": [
{ "question_id": "…", "score": 80, "student_answer": "What they said, in one sentence", "comment": "Why that score", "covered": true }
],
"summary": "…",
"strong_points": ["…"],
"weak_points": ["…"]
}
  • The agent must tell the student the grade AcademIA returns, not one it worked out itself.
  • A session takes a single result; a second one is refused.
  • The credential’s key needs the Voice and mentor sessions permission, which a Super admin grants in Platform › API keys. Without it, AcademIA refuses the session. It reads any quiz of the platform through the session, so it does not need a SUPER_ADMIN.
  • Add both operations as tools of the voice agent, with Session ID and Result (JSON) left to the AI.

Mentor Sessions (the course mentor in AcademIA)

In AcademIA, the student asks the course mentor their questions from a lesson (This lesson) or from the whole course (Whole course). AcademIA runs your flow with the question as the chat message and with that conversation’s ID as the run’s session. With these two operations the flow knows which student is asking and what they are looking at.

OperationWhat it doesFields
Get Mentor SessionReturns the student, the course, the lesson they are on, the course outline, the conversation so far and a text with all of it ready for the agent’s instructions.Optional: Mentor session ID. Leave it empty: the run’s session is used, which is the one AcademIA sends.
Get Mentor LessonReturns another lesson of the same course with its content, only if the student can see it.Lesson ID (from the outline Get Mentor Session returns). Optional: Mentor session ID, as above.

Get Mentor Session returns:

  • scope: LESSON if the student asks from a lesson, COURSE if they ask about the whole course.
  • language: the student’s language. The agent should answer in it.
  • student: the student’s name (first_name).
  • course: the course, with id, title and description.
  • current_lesson: the lesson they are on, with id, title, module and content. Empty with COURSE.
  • outline: the modules with their lessons (id, title, summary and current, which marks the current one).
  • full_course: true when every lesson comes with its content.
  • history: the earlier messages of this conversation.
  • context: all of the above in a single text, ready for the agent’s instructions.

How to set it up:

  • Add Get Mentor Session as a normal component before the agent, not as a tool, and take its context to the agent’s instructions, for example with Parse Data ({context}) and a Prompt. That way every question arrives with its context.
  • Give Get Mentor Lesson to the agent as a tool, with Lesson ID left to the AI, so it opens another lesson only when the question needs it.
  • Voice mentor: if the student clicks Talk to the mentor, AcademIA calls a voice agent and the call context carries mentor_session:<id>. Add both operations as tools of the voice agent, with Mentor session ID left to the AI, and have it load the session before greeting the student by name.
  • AcademIA decides which student, course and lesson, and only serves what that student can see. Quiz answers never come.
  • The credential’s key needs the Voice and mentor sessions permission, as for Voice Sessions. Only IDs of mentor conversations are accepted.

Translations (a path’s translations)

OperationWhat it doesFields
Estimate TranslationWorks out the cost and size of translating the path into the chosen languages.Path ID. Optional: Languages and Retranslate all.
Run TranslationStarts the automatic translation of the path.Path ID. Optional: Languages and Retranslate all.
Translation StatusShows how the translation is going in each language.Path ID. Optional: Per item.
  • Languages are the target languages separated by commas: es, en, pt-BR, fr, it, de or ca-ES-valencia. If you leave it empty, the target languages the path already has are used.
  • Retranslate all counts or translates everything again, including what is already translated.
  • Run Translation adds to the path the requested languages it didn’t have yet and returns the ID of the translation task (aiTaskId).
  • Per item: off, it returns the totals and progress per language; on, every lesson, quiz and game with its status.

Output

The Data output returns AcademIA’s answer as data: one item per path in List Paths, and the path, the estimate or the status in the others. The path created with Create Path carries its ID in id, which you can pass to the next step.

The component supports Batch Mode and it can be connected to an Agent as a tool. See Tools.

Example

A consultancy wants to turn its internal manuals into AcademIA courses.

  1. The flow receives the manual and an AI model with Structured Output writes the syllabus as a list of modules with their lessons, in the Modules (JSON) format.
  2. Add AcademIA Content with the Paths resource and the Create Path operation. Fill in Title and Description with the ones the model suggests.
  3. Connect a second AcademIA Content with the Import Curriculum operation: in Path ID the id of the newly created path and in Modules (JSON) the syllabus.
  4. Review the course in AcademIA and publish it with Publish Path, or then run Run Translation with en in Languages.

Good practices

  • Before translating, use Estimate Translation to see the cost.
  • Import Curriculum needs the list of modules in JSON. Plain text won’t do: ask the model for a structured output.
  • Path IDs come from List Paths or from the result of Create Path. Don’t type made-up values.
  • To have AcademIA’s own AI generate quizzes, games or a syllabus, use AcademIA AI Tasks.

Security and limitations

  • Paths are created unpublished, and the modules and lessons from Import Curriculum also arrive unpublished.
  • Publish Path publishes only the path: its modules and lessons keep their own status. Review and publish them in AcademIA.
  • Import Curriculum always adds at the end: if you run it twice, the modules end up repeated.