add_author
ChatGPTRecord one external author who created this material. Use evidence from the material or the user; never infer authorship from a copied source. Use add_credit for external sources. Platform account authors cannot be added here.
Education & Research
Overview
Praktikal is an education platform for teachers and learners. Connect your Praktikal account to find and read accessible teaching materials, create and adapt lessons, build presentations, and practice with interactive questions in ChatGPT. The included workflow skill guides material searches, lesson authoring, and question practice, and loads specialized Praktikal playbooks when needed. Available tools and materials depend on your account permissions and the access granted during connection. A Praktikal account is required.
Tools
add_credit
ChatGPTRecord one external source used in this material. State only the licence verified at the source; use undeclared when no licence can be verified. This does not set the material’s own licence or authors.
add_learning_connections
ChatGPTAdd learning connections to material. Choose connection.kind: focus for lesson learning focuses, outcome for worksheet learning outcomes, curriculum_position for curriculum tags or competencies. Each kind declares its exact target and inputs below. Existing connections are preserved; linking an outcome never implicitly adds curriculum positions.
add_set_members
ChatGPTAdd existing nodes to a set by reference, preserving other members and clearing exclusions for these nodes. The content stays where it is and is not copied.
attach_instruments
ChatGPTAttach instruments to a node or add one existing instrument/nested kit to a kit. Choose target.kind node or kit. Other attachments survive; reattaching can overwrite quantities. Node targets accept existing exp_id values or titles for new instruments; kit targets require existing instrument_id values.
copy_node
ChatGPTCreate an independent deep copy of a readable node tree under the current account. Use this before localizing licensed or shared content. Copy permission is checked using the same access rules as the platform; the source remains unchanged and every copied child receives independent ownership. Copying a set is different in kind: a set holds content by reference, so the copy points at the same material rather than duplicating it, and members this account cannot read are left out and reported in
dropped_member_count.create_lecture
ChatGPTCreate a new lesson (tree root) with an initial empty module, owned by the caller. Use when the user asks to start a new lesson, lecture, or learning unit. Returns lecture_root_id and module_id — use the module_id as parent_node_id in CREATE_NODE to add worksheets and content directly. To find existing lessons, call SEARCH_NODES with
node_types: ["sblesson"].create_node
ChatGPTCreate one or more NEW nodes (text, question, media, worksheet, structure, …).
node_type_name selects the node kind; call describe_node_type for that kind and put the fields its creation_schema names into fields. Title and placement stay at the top level. To create several nodes at once (e.g. a worksheet full of questions), pass nodes: [...] instead. Use this to mint content from scratch. To place an already-existing node under a new parent without duplicating it (link/copy semantics), use INSERT_NODE instead.create_set
ChatGPTCreate a set: a named, shareable collection of repository content. A set holds content two ways and can combine both — hand-picked members listed in
member_node_ids, and a stored filter that is re-run every time the set is opened, so new matching content joins on its own. Prefer a filter when the teacher describes a rule ("all my optics multiple-choice questions"), and hand-picked members when they name specific material. A set collects content; it does not copy or move it, and it grants nobody access to what is inside it.create_skill
ChatGPTCreate a new reusable assistant skill (a saved expert playbook for a recurring teaching task), owned by the caller. Provide the markdown body as the full instructions the assistant should follow when the skill applies. Optionally attach references — focused supporting documents loaded on demand. Use when the user asks to save, capture, or author a skill. To revise an existing skill, use update_skill.
create_slideshow
ChatGPTCreate a new slideshow over an existing lecture. Requires the lecture contains worksheet nodes. The slideshow starts in the WAITING lobby — call OPEN_SLIDESHOW to get its URL; the owner then clicks Start Presentation in the lobby to go live.
create_upload
ChatGPTCreate a one-time local-file upload URL. Choose target.kind image for a picture or file for a document or 3D model. Run the returned upload_command to transfer the bytes. Images may be staged without a destination; files require a title for a new node or node_id to replace an existing attachment. Replacement overwrites the current image or attachment. Uploads require a client that can execute shell commands.
delete_set
ChatGPTDelete a set. Only the set itself goes: it holds content by reference, so nothing that was in it is touched and nothing is lost from the repository. Anyone the set was shared with loses the collection, not the material. Deleting is also how an account over its plan allowance gets back under it, so it stays available even when the set cannot otherwise be edited.
describe_node_type
ChatGPTDescribe the creation, update, native explanation, and answer-key contract for one node type. Call this before CREATE_NODE for any type whose fields you are not certain of:
creation_schema lists exactly the fields that type accepts, and create_node refuses fields it does not name. Also authoritative for READ_NODE.authoring and UPDATE_NODE.authoring_patch.detach_instruments
ChatGPTDetach specified instruments from a node or remove one member from a kit. Choose target.kind node or kit. Other attachments and the instrument or nested kit itself survive.
detach_node
ChatGPTDetach a node from one parent, removing it from that place in the tree. This does NOT delete the node: it stays in the repository and keeps every other parent it had, so a node used in several lessons is only removed from the one you name. The response reports the parents that remain and whether the node is now unattached. To re-place a detached node, use INSERT_NODE; to move it to a different parent in one step, use MOVE_NODE.
edit_canvas
ChatGPTLoad the
canvas-authoring skill with read_skill before your first call — this takes a Praktikal canvas document, which is not Excalidraw, tldraw or any other format you may know, and a document in the wrong shape is refused whole. Draw or edit a native canvas atomically using stable element IDs. This is how a canvas node gets its content: create the node empty with create_node, then send the whole document here with base_revision null. The skill carries the document envelope, the node kinds (shape/path/text/image/group/connector/instance) and their properties, and the layout rules; a document that misses a required field is refused whole. Afterwards read_canvas and send operations instead, passing the revision it returned as base_revision, and a unique request_id reused only for an exact retry. Operations: set/remove/insert/move/replace-text/style-text (UTF-16 text offsets), create-component/insert-instance/update-component/remove-component/override-instance/reset-instance/detach-instance. Nested component definitions live in document.components; override keys identify source nodes in the resolved definition. Cycles are rejected. Detaching preserves nested child instances. The server renders the SVG preview from the document — the node takes no image of its own. For a hand-drawn look the skill covers roughness, fillStyle, connection.roughness, the handwriting font Excalifont and tapered freehand pencil paths. No changes commit if validation or rendering fails.edit_html_artifact
ChatGPTMake targeted edits to an existing htmlArtifact node without resending the whole document. Each edit replaces an exact substring of the current HTML. Read the node first (read_node, mode "full") to get the current HTML, then pass small, surgical edits. Rules for each edit: • old_string must match the current HTML EXACTLY — including whitespace and indentation — and must be unique unless replace_all is true. • Include a few surrounding lines/characters so old_string is unambiguous. • new_string must obey the same authoring constraints as the original artifact (self-contained, allowlisted CDNs only, no network calls). Edits apply in order; if any old_string is missing or non-unique the whole call fails and nothing is changed. For a full rewrite, use update_node with the complete html in
content instead.edit_slide
ChatGPTCompose a slide without rewriting it: layout, background, heading, decorative shapes, and where and how each element on it is drawn. Read it with read_slide first and pass its revision as base_revision; a stale revision is refused. Operations apply in order and are all checked before anything is written. In every operation an omitted field is left as it is and null clears it. - set_layout: single, two-column, main-sidebar, three-column, two-row, grid-2x2, or free (every element has its own box). Switching keeps the arrangement. - set_background: color, image_reference or image_url (replaces the picture), remove_image. - set_heading: rect and color (free slides), align, size. The heading text is changed with update_node. - set_element node_id: area (divided slides, as read_slide lists them) or rect (free slides); align and valign (free) start|center|end; show_title; text_size and line_spacing on text, formula, table and callout (idea, concept, warning, instructions) elements, text_fit (free) on text only; background, background_opacity, opacity; border_width, border_color, border_radius, padding; button {label, size, color} to open the element from a button (free; {} for defaults); participant true to move it to the participants' own screen in a live session. - order_element node_id before_node_id (null = last); later elements draw on top. - set_shape: without id adds a shape (type rectangle|circle|vertical-line|horizontal-line and rect required); with id changes one. z, fill_color, border_color, border_width, border_style, border_radius, opacity. remove_shape id. Units: a rect is {x, y, w, h} in percent of the slide area inside its padding, w and h at least 5. Sizes, borders, radii and padding are pixels of the 1920×1080 slide: text 12–240 (default 32, heading 64), border up to 40, radius and padding up to 200. line_spacing 0.8–3, opacities 0–1. Out-of-range values are clamped. Colours are CSS: "#fefceb", "rgb(254 252 235)" or a keyword. Elements are added with insert_node and removed with detach_node; their content and view are changed with update_node. Load the
slide-composition skill with read_skill for layout choice and projector readability.edit_table
ChatGPTChange individual cells of a table, or add and remove its rows and columns, without rewriting the whole table. Read it with read_table first and pass the revision it returned as base_revision; an edit against a stale revision is refused rather than written into the wrong cell. Operations apply in order: set_cell (text, alignment, header cell, picture), insert_row, remove_row, insert_column, remove_column. A cell picture is a child image node of the table: set_cell takes image_reference or image_url to add one, image_node_id to show a picture the table already holds in another cell as well, and image_node_id null to clear the cell. A picture no cell shows any more is removed from the table. Prefer this over update_node for an existing table — update_node replaces the whole content and strands every picture the markup stops naming.
ensure_extras_container
ChatGPTReturn the extras container for a node, creating it if absent. Use its container_id as the parent for supplementary materials. Repeated calls reuse the container.
fetch
ChatGPTUse this when ChatGPT needs the full text for one accessible Praktikal search result by id. Returns a citation URL and compact document metadata.
import_ekoolikott_material
ChatGPTCopy an E-Koolikott material into the teacher's own Praktikal repository. Activities are converted into native Praktikal nodes where they can be — questions, text, media — and anything that will not convert is kept as a working embed, so a copy never lands broken. The source licence and authors are recorded as credit on what it creates. Read the material first if the teacher wants only part of it: pass the
part_ids they do not want as skip_parts. The copy is additive: it creates new nodes and changes nothing that was already there. Every root it created comes back in root_node_ids. A copy made with into_node_id can be taken back out with detach_node; one that built its own artifact is a top-level node, which no tool removes — the teacher deletes it in Praktikal if they do not want it.insert_inline_computed_value
ChatGPTInsert an inline computed-value atom by appending it or replacing exact anchor text in a node. Read the node in full mode first and reuse exact formula_reference strings.
insert_node
ChatGPTPlace an EXISTING node; CREATE_NODE creates new content.
reference shares edits across placements; copy makes an independent duplicate. Omitted mode references same-owner nodes and copies others, subject to licence. Use copy for localization/adaptation. relationship="explanation" attaches a container tree as a native worked solution; clear any existing explanation. References need source write access and matching ownership; copies need copy permission.list_curricula
ChatGPTList the curricula (national or school teaching frameworks) this account can read: the ones it owns, the ones it maintains — including unpublished drafts — and every published curriculum. Start here to get a curriculum id, then use read_curriculum_tree to explore its structure or search_curriculum_positions to jump straight to a subject or topic.
list_my_slideshows
ChatGPTList slideshows owned by the current user. Returns id, title, status, and creation timestamp (up to 50 by default). Use this to find an existing slideshow to launch or reference.
list_skills
ChatGPTList the reusable assistant skills available in this session. Skills are saved, expert playbooks for recurring teaching tasks. Returns metadata only (id, name, description, audience), not the skill body. Before doing relevant work, scan this list and call read_skill to load the full instructions for any matching skill.
morph_node
ChatGPTChange an existing node to a different type in place, keeping its id, its placements and any student responses already recorded against it. Only the conversions Disco allows are possible — read the node first and use its
allowed_morph_targets. Prefer this over deleting and recreating: a replacement node is a new identity, which breaks scoring history and any reference pointing at the original.move_node
ChatGPTMove a node to a new parent or reorder it within the same parent. Can move to a different parent or reorder among siblings by specifying a new index.
open_slideshow
ChatGPTGet the Praktikal Play URL for a slideshow so the user can open it. Does not change slideshow state — the owner still clicks Start Presentation in the lobby when ready.
publish_computed_value
ChatGPTPublish a numeric/math question, numerical table cell or table column as a reusable computed-value variable. Re-publishing may change its display name.
read_adventure_route
ChatGPTRead how learners move through a lesson: its stops (one per slide), the questions on each stop with their option ids and max points, and the navigation rules currently in force. Always call this before set_adventure_route: stop ids, question ids and option ids all come from here, and a lesson with no saved route still returns the implicit slide-order one you would be editing. Needs edit access to the lesson: the stops carry its answer key.
read_asset
ChatGPTRead an image or attachment. Choose target.kind node_image with node_id for an existing node image (SVG markup or raster image), or snapshot_asset with an account-scoped asset_handle from read_tree_snapshot for metadata, original content, extracted document text or a rendered page. Snapshot handles expire and current access is rechecked.
read_curriculum
ChatGPTRead a curriculum. Choose view tree for its structure, scoped branches and depth-limited content; start with include structure and a small depth. Choose view node for one item with its full rendered body. Both views require curriculum_id and enforce membership and access within that curriculum.
read_ekoolikott_material
ChatGPTRead one E-Koolikott material: what it is, who made it, how it is licensed, and the parts it is built from. Returns a table of contents rather than the content itself — enough to decide what is worth copying and which parts to leave behind. Each part carries a
part_id to pass to import_ekoolikott_material as skip_parts. suggested_artifact_kind is what the material looks like it should become; override it on the import only when the teacher wants something else.read_node
ChatGPTFetch tree structure and detailed content for specific node IDs. Use to inspect node content, understand tree structure, or gather information before modifications. Essential before inserting, updating, or deleting. Full mode returns editable raw fields, placement, provenance, and metadata the caller may edit. Authors also receive real option IDs, correctness, answers, and explanations; read-only callers receive the redacted definition view. Full mode also returns computed_values with exact formula_reference and atom_html anchors for computed-value operations, grading_mode and allowed_morph_targets for questions, and provenance.parentIds so a node shared between lessons is visible as such. For a quick table-of-contents of a book or lesson, use mode: "structure" with max_depth: 2. For user-facing visual display of a single node, use VIEW_NODE instead. In full mode, requested board, canvas, table and slide roots also return content_state entries containing their structured editable state and save revision. Read the target node directly before updating its content. Descendant nodes are not expanded into content_state; request their IDs directly. Canvas state retains the empty starter document and legacy_svg warning; never replace a legacy drawing without explicit intent. Optional include sections return complete results in details for each requested root; extras includes the container ID, instruments includes quantities and kit contents, ancestors includes every lineage. Rights includes terms, authors and credits, with management identifiers only when permitted; rights.include_management controls that view. Learning connections includes learning alignment and requires curriculum:read. Translations returns stored title/summary translations for instruments, kits and components.
read_results
ChatGPTRead learning results. Choose target.kind question for per-student responses to one question, optionally within a slideshow, or slideshow for per-question session summaries. Results require ownership checks; grades and answer keys require their additional scopes. Question responses are capped at 200.
read_set
ChatGPTRead one set: its name, description, stored filter, and a page of the content it currently resolves to. Membership is resolved fresh on every read — hand-picked members first in the order the owner gave them, then whatever the stored filter matches now, minus anything excluded. A set grants no access to its contents: members the caller cannot read on their own are simply absent, so two people can read the same set and see different amounts of it. For a caller who may change the set this also reports its exclusions and how much of it a recipient would miss.
read_skill
ChatGPTRead an assistant skill or one of its supporting references. Choose target.kind skill with a skill_id from list_skills; then use target.kind reference with a reference_id listed by that skill when its instructions require it. Both targets enforce actor access and session audience restrictions.
read_slideshow_content
ChatGPTRead the content of a slideshow — slides, questions, text, and structure. Use when a user shares a Praktikal Play link (play.praktikal.ee/slideshow/ID) or mentions a slideshow and wants help studying the material. Extract the slideshow ID from the URL. Returns all visible slide content with node IDs. Then use VIEW_NODE on individual question or content node IDs to show them as visual cards in the chat — do not re-type question text as plain text.
read_tree_changelog
ChatGPTRead the authoring history of a tree: what changed under a node, when, and who changed it. Covers the node and everything structurally beneath it, one entry per changed field, newest first, including nodes that were deleted. Use it to review what an agent or a colleague just did, to audit a shared collection, or to find what has moved since a date. Narrow with start_date, end_date and account_id rather than paging through everything. This reports history only — read_node shows what a node says now.
read_tree_snapshot
ChatGPTCreate or continue a stable, paginated full-tree snapshot for audits and transformations. Unlike READ_NODE, this separates distinct node records from ordered parent-child placements, includes per-node content hashes and version IDs, and keeps continuation pages fixed for 30 minutes. Start with root_node_id alone. To continue, repeat the snapshot_id you were given with the next_cursor from the page you just received, one page at a time — do not guess cursor values ahead of a response. Stop when has_more is false.
remove_author
ChatGPTRemove one external author from this material using an author_id from read_node details.rights.management.authors (include rights). Platform account authors cannot be removed here.
remove_computed_aggregate
ChatGPTRemove a sum or mean aggregate from a table column. Formulas referencing it may stop resolving.
remove_computed_formula
ChatGPTRemove the computed formula from a table cell or column.
remove_credit
ChatGPTRemove one external-source credit from the specified material using a credit_id returned in read_node details.rights.management.credits (include rights).
remove_extras_container
ChatGPTRemove the entire extras section from a node. The supplementary materials themselves survive in the repository.
remove_inline_computed_value
ChatGPTRemove an inline computed-value atom matched by exact atom_html from a full node read.
remove_learning_connections
ChatGPTRemove specified learning connections from material. Choose connection.kind: focus, outcome, or curriculum_position. This detaches only the specified connections; the connected nodes and their other uses survive. Missing connections are harmless.
remove_set_members
ChatGPTRemove specified nodes from a set without deleting the content. Filter-backed sets record exclusions so those nodes do not immediately match again.
reorder_set_members
ChatGPTChange the order of hand-picked members in a set. Supply their IDs in the desired order. Omitted members retain their positions; filter matches keep their own sort order after hand-picked members.
search
ChatGPTUse this when ChatGPT needs to search accessible Praktikal teaching content for company knowledge, deep research, or citation-oriented retrieval. Returns canonical result ids, titles, and URLs.
search_curriculum_outcomes
ChatGPTList the learning outcomes of a curriculum, filtered by scope, outcome type and free text, with the ancestor chain of each one so you can see where it sits. Set coverage=true to also get, per outcome, the published Praktikal materials that already cover it plus a covered/uncovered summary — the fastest way to find the gaps worth authoring for.
search_curriculum_positions
ChatGPTFuzzy-search inside one curriculum for a taggable position — a subject, grade, course or topic — and get its node id back. Curriculum nodes are deliberately kept out of ordinary repository search, so this is the way to find one by name instead of walking the tree with read_curriculum_tree. Set kind="outcome" to search learning outcomes, or kind="competency" for general competencies.
search_ekoolikott
ChatGPTSearch E-Koolikott, the Estonian national repository of open learning material, for material the teacher does not have yet. This is a different corpus from search_nodes, which searches the caller's own Praktikal repository — reach for this one when the teacher asks what exists on a topic rather than what they already have. Results are public Estonian material, mostly in Estonian. Pass a returned
material_id to read_ekoolikott_material to see what it holds, and to import_ekoolikott_material to copy it in.search_instruments
ChatGPTSearch for realia (instruments and kits) by text query, filtered by access level. Results carry
url, the user-facing Praktikal link to the item.search_nodes
ChatGPTSearch the caller's repository for existing nodes. Supports free-text search, node type inclusion/exclusion, access level (own / shared / public / link / license / maintained / organization), language, content-presence filters, sort field + direction, and scoping to a sub-tree via
in_tree. Results include url — the user-facing Praktikal link. To render a node inline as an interactive card, call VIEW_NODE with its node_id; do not try to embed search results directly. To list lessons: node_types: ["sblesson"]. To list books: node_types: ["book"]. To list collections (curated packs): node_types: ["collection"]. To find questions in a chapter or module: combine in_tree with question type names. To find reusable learning connections, search only learningFocus, learningOutcome, or both; those type-only searches include connected items that stay hidden from ordinary repository browsing. To list sets — named, shareable collections of repository content — search only set; they are hidden from ordinary browsing for the same reason, so a set never appears among the content it collects. Then use READ_SET to see what one holds. Set as_tree: true (with in_tree) to get a pruned hierarchy of matches and their ancestor chain instead of a flat list — use this when the structure of where matches sit matters.set_adventure_route
ChatGPTSet how learners move through a lesson: gate a stop behind its questions, branch on which option they picked or on how many points they scored, or send them somewhere other than the next slide. Call read_adventure_route first for the stop, question and option ids. Only the stops you list are changed; every other stop keeps its navigation. The route is saved on the lesson, so slideshows started from it inherit it. Rejects the whole write if the result would leave a learner stranded.
set_computed_aggregate
ChatGPTSet or replace a sum or mean aggregate on a table column, with optional display name, number format and unit.
set_computed_formula
ChatGPTSet or replace the formula of a table cell or column. Read the node in full mode first and reuse exact formula_reference strings.
set_learning_outcome_type
ChatGPTSet or clear the classification of a teacher-editable learning outcome without exposing how that classification is stored. Use null to clear it. Curriculum-owned and external outcomes cannot be changed.
set_question_max_points
ChatGPTSet how many points each question in a lesson is worth. Scores drive grading and any points-based branch rule, and a question left at 0 can never satisfy one, so set these before branching on score. Points are stored per lesson, so the same question reused elsewhere is unaffected.
set_realia_translations
ChatGPTCorrect title or summary translations for realia you may edit. Changes overwrite machine translations for matching source strings platform-wide, affecting other items with identical text. Human translations retain precedence. Entries in the source language are ignored.
unpublish_computed_value
ChatGPTStop publishing a question, table cell or table column as a computed-value variable. Existing formulas referencing it may stop resolving.
update_credit
ChatGPTReplace an external-source credit on this material. Omitted attribution_url clears the previous URL. Change teacher-entered credits only when asked or demonstrably wrong. Use undeclared for an unverified licence. Withdrawn attribution cannot be rewritten.
update_inline_computed_value
ChatGPTUpdate an existing inline computed-value atom matched by exact atom_html from a full node read. Supply only the attributes to change.
update_node
ChatGPTPatch an existing node. Identity, placement and preconditions are top-level; everything type-specific goes in
fields. Call DESCRIBE_NODE_TYPE for the node type to learn which fields it accepts — an inapplicable field is rejected, not ignored. Only include fields you want to change.update_node_image
ChatGPTReplace a node's image. Accepts local files staged with create_image_upload, session-uploaded images, embedded document images, or a remote HTTP(S) image URL. A canvas node is not an image: edit its drawing with edit_canvas.
update_set
ChatGPTRename a set, change its description, or replace the stored filter it resolves through. Only the fields you send change. A filter is replaced wholesale, never merged — send the complete query you want, and send
filter: null to drop it and leave a hand-picked set. Hand-picked members and exclusions survive a filter change untouched, so an item excluded under an older filter stays excluded under the new one.update_skill
ChatGPTUpdate an existing assistant skill the caller can edit. Only the provided fields change; omit a field to leave it untouched. Passing references replaces the reference set: items with an id update that reference, items without one are added, and existing references left out are removed. Use after read_skill identifies the skill to revise.
view_node
ChatGPTRender a single Disco node inline as an interactive card in the chat. Use to show questions, text, images, or any content node to the user. Questions render with answer options — the student can answer directly in the card and the answer is sent back to the conversation. When quizzing a student on material from a slideshow or lesson, use this tool with each question node_id instead of re-typing question text. Use READ_NODE for your own reasoning, VIEW_NODE for user-facing display.
Capabilities
InteractiveWrites
Example Prompts
Click any prompt to copy it.
