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.
| Field | What it does |
|---|---|
| Credential (required) | The AcademIA credential. It fills in AcademIA API address and AcademIA API key for you. |
| Resource | What you work with: Paths, Quizzes, Voice Sessions, Mentor Sessions (the course mentor’s sessions) or Translations. Default: Paths. |
| Operation | What 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)
| Operation | What it does | Fields |
|---|---|---|
List Paths | Returns the paths the key can edit, with their publication status, modules and enrollments. | Optional: Enrollment mode (Any, OPEN or INVITATION_ONLY). |
Get Path | Returns one path with its settings and modules. | Path ID |
Create Path | Creates a new, unpublished path. | Title, Description. Optional: Slug, Access, Language, Enrollment mode, Difficulty and Estimated hours. |
Import Curriculum | Adds modules and lessons at the end of a path, unpublished. | Path ID, Modules (JSON). Optional: AI task ID. |
Publish Path | Publishes 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_ELITEorCORPORATE. - Language is the language the content is written in:
es(default),en,pt-BR,fr,it,deorca-ES-valencia. - Enrollment mode:
OPEN(anyone can enroll, default) orINVITATION_ONLY(by invitation only). - Difficulty is free text, for example
Principiante,IntermedioorAvanzado. Default:Principiante. - Estimated hours is the estimated number of hours, for example
6or2.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)
| Operation | What it does | Fields |
|---|---|---|
List Quizzes | Lists the quizzes you can edit, with their module, their path and how many questions they have. | |
Get Quiz | Returns a quiz with its questions and the teacher’s grading criteria. | Quiz ID |
Get Module Quiz | The 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.
| Operation | What it does | Fields |
|---|---|---|
Get Voice Session | Returns 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 Result | Sends 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.
| Operation | What it does | Fields |
|---|---|---|
Get Mentor Session | Returns 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 Lesson | Returns 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:LESSONif the student asks from a lesson,COURSEif 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, withid,titleanddescription.current_lesson: the lesson they are on, withid,title,moduleandcontent. Empty withCOURSE.outline: the modules with their lessons (id,title,summaryandcurrent, 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 Sessionas a normal component before the agent, not as a tool, and take itscontextto the agent’s instructions, for example with Parse Data ({context}) and a Prompt. That way every question arrives with its context. - Give
Get Mentor Lessonto 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)
| Operation | What it does | Fields |
|---|---|---|
Estimate Translation | Works out the cost and size of translating the path into the chosen languages. | Path ID. Optional: Languages and Retranslate all. |
Run Translation | Starts the automatic translation of the path. | Path ID. Optional: Languages and Retranslate all. |
Translation Status | Shows 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,deorca-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 Translationadds 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.
- 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.
- Add AcademIA Content with the
Pathsresource and theCreate Pathoperation. Fill in Title and Description with the ones the model suggests. - Connect a second AcademIA Content with the
Import Curriculumoperation: in Path ID theidof the newly created path and in Modules (JSON) the syllabus. - Review the course in AcademIA and publish it with
Publish Path, or then runRun Translationwithenin Languages.
Good practices
- Before translating, use
Estimate Translationto see the cost. Import Curriculumneeds the list of modules in JSON. Plain text won’t do: ask the model for a structured output.- Path IDs come from
List Pathsor from the result ofCreate 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 Curriculumalso arrive unpublished. Publish Pathpublishes only the path: its modules and lessons keep their own status. Review and publish them in AcademIA.Import Curriculumalways adds at the end: if you run it twice, the modules end up repeated.
Related components
- AcademIA AI Tasks: AcademIA’s AI generators.
- AcademIA Enrollment: invite and enroll people in your paths.
- AcademIA MCP: an agent that writes and reviews courses.