add_dashboard_card
ChatGPTAdd one card to a results dashboard. Four card types: "question" and "recode" chart a question and require card_id (the card_id of the question in get_results_map); "content" is an editorial block and needs content.sub_type set to "section" (a title splitting the dashboard, its wording in content.title) or "text" (a comment, its wording in content.text); "analysis" is a computed block (crosstab, KPI, funnel, TURF, key drivers, map, word cloud…) whose content.sub_type names the analysis — pick it with list_analysis_card_types and fill content and options exactly as describe_analysis_card_type says, with question ids and answer codes from get_results_map; a card whose ids are wrong renders empty. insert_at is 1-based and pushes the cards below it down, so you can place a card without renumbering the rest; omit it to append at the end. Read get_dashboard first to know the current positions.
add_survey_context_text
ChatGPTAdd a text the user gave in the conversation (brief, kick-off notes, previous results, an email) as a source of the survey context. It is not written into the context itself: call generate_survey_context afterwards to have Episto AI use it. For files on the user’s machine, use create_context_upload_link instead. 50 sources at most per survey.
ask_grid_question
ChatGPTAdds one AI question column per prompt to a grid: each question is answered from the interviews, once per row — per respondent on a respondent grid, over the whole population on a population grid, where a comparative summary is generated on top. The answers are produced in the background: the tool returns each column id and its number of pending cells, then call get_grid until each one is done or failed. One generation runs per row, so a question costs as many model calls as the grid has rows — on default, one per respondent of the survey.
ask_survey_context_source
ChatGPTHave Episto AI read a whole source of the survey context (pasted text, PDF, Office or OpenDocument file, spreadsheet, text, image or mail) and answer one precise question from it: figures, quotes, a table, what a slide shows. Use it when the context and its "Sources" map are not enough. A source describes the study, it is not what respondents answered. It can take a few minutes: ask everything you need from a source in one question. Source tokens come from get_survey_context.
create_card
ChatGPTInsert a new card (question, message or operation) in the questionnaire. type is a card type string (q_single, q_multiple, q_open, q_nps, q_rating, m_text…). specs carries the type-specific fields — call describe_card_type for the fields the type expects; localized texts are keyed by the survey locale tokens. Elements of a collection (answers, items, images…) get a generated token when you omit it — supply one only to give it a readable identifier you reference in the same call. previous_card_token positions the card right after that one; omit it to append at the end, or pass position 'first' to insert at the top (of section_token, else of the questionnaire). Every card belongs to a section: pass section_token (from list_sections) to choose it, otherwise the new card joins the section of previous_card_token (the first section by default) — use move_card to change it. The platform validates the card and answers 422 with the validation messages — fix the specs and retry, nothing is persisted while errors remain.
create_card_image_upload_link
ChatGPTMint a short-lived pre-authorized URL that hosts images for the questions of a survey: image-choice answers, ranking answers (display_answer_images) and matrix items (display_item_images). This is THE way to bring images from the user’s machine: bytes must never travel through the conversation, so the link carries the upload instead. One plain multipart POST per image (or several "file" fields in one POST), no auth header — the link itself is the authorization. The POST response lists { file, url } for each hosted image; nothing is attached to a card yet. Use the link like this: (1) if you can run shell commands on the machine holding the images, curl them — curl -sS -F "file=@/path/photo.png" "<upload_url>" — and read the urls from the response; (2) otherwise give the user the link to open: it is a drag-and-drop page that shows the url of each uploaded image, ask the user to paste them back. Never read the files yourself to re-send them. Then write each url into the url of its answer or item with create_card / update_card, keyed by locale like the element title (describe_card_type). An image already reachable at a public URL needs no upload. Images only (jpg, jpeg, png, webp, avif, gif), 30 MB max each, link valid 2 hours. Needs edit rights on the survey.
create_cards
ChatGPTInsert several cards in one call, and the sections holding them when they are new: a whole questionnaire or a block of questions, where create_card adds one card. Each card takes the type, name and specs of create_card (list_card_types for the types, describe_card_type for the specs each type expects). sections creates new sections with their cards, each placed after previous_section_token or after the previous section of the call (the end of the questionnaire by default); cards adds cards to existing sections with the placement options of create_card, a card without them following the previous card of the call, sections included (the end of the questionnaire for the first). Both lists can be combined; sections are created first, then cards, in the order given. Give a card a token to reference it in a condition of a later card of the same call (conditions[].card_token), as for answers; a condition can only reference a card already in the survey or earlier in the call. All or nothing: the platform validates every card and answers 422 with the messages per card (sections[i].cards[j], cards[k]) — fix them and send the whole call again, nothing is persisted while errors remain.
create_codification_recode
ChatGPTCodify free text into categories: the AI reads every verbatim of an open question — or every AI Chat interview — and assigns each respondent to the categories you define. This is how a qualitative question becomes analysable alongside the closed ones. Read the verbatims first with get_individual_data to decide the categories, then name them here; the AI matches the text against them following ai_instruction. Call get_results_map for the source card token. Codifications are analysis recodes by nature: they run on collected text, so they default to the analysis origin whatever the survey status. The answers of an analysis recode are computed asynchronously after the card is created, so re-read the survey a moment later to see them; a programming recode is computed as each respondent passes. The response states the origin retained and where the recode is visible — repeat it to the user. Nothing is persisted while the card is invalid: the platform answers with the validation messages, so fix them and retry.
create_conditions_recode
ChatGPTCreate a recode whose categories are defined by conditions across several questions, rather than by one source question — segments like "urban parents" or "detractors who also cancelled". Mode 'single' assigns each respondent to the first category whose conditions match, 'multiple' to every category that matches. Call get_survey_map first: conditions reference a card by its token and its answers by their token (not their code). A matrix is targeted item by item: send its card_token plus the item_token. A respondent attribute is read by name with card_token '__user_attribute__' plus attribute_name. Only send card_token, type, values and operator — the platform derives the rest. The answers of an analysis recode are computed asynchronously after the card is created, so re-read the survey a moment later to see them; a programming recode is computed as each respondent passes. The response states the origin retained and where the recode is visible — repeat it to the user. Nothing is persisted while the card is invalid: the platform answers with the validation messages, so fix them and retry.
create_contact_attribute_recode
ChatGPTTurn an attribute carried by the mailing list contacts into an analysable question — loyalty tier, region, subscription plan, anything the client sent along with the email addresses. Call list_contact_attributes first for the available names: an attribute holding free text is kept verbatim, while one with known values can be grouped through categories. The tool picks the right transformation from the attribute itself, so you only choose the grouping. The answers of an analysis recode are computed asynchronously after the card is created, so re-read the survey a moment later to see them; a programming recode is computed as each respondent passes. The response states the origin retained and where the recode is visible — repeat it to the user. Nothing is persisted while the card is invalid: the platform answers with the validation messages, so fix them and retry.
create_context_upload_link
ChatGPTMint a short-lived pre-authorized URL that receives files as sources of a survey context (briefs, kick-off notes, previous results, decks). This is THE way to bring files from the user’s machine: bytes must never travel through the conversation, so the link carries the upload instead. One plain multipart POST per file (or several "file" fields in one POST), no auth header — the link itself is the authorization. Each accepted file becomes a source of the survey; the POST response lists them. Use the link like this: (1) if you can run shell commands on the machine holding the files, curl them — curl -sS -F "file=@/path/brief.pdf" -F "file=@/path/notes.docx" "<upload_url>"; (2) otherwise give the user the link to open: it is a drag-and-drop page in the browser. Never read the files yourself to re-send them. PDF, Office, OpenDocument, images, text and mail files only (.pdf, .doc, .docx, .ppt, .pptx, .odt, .odp, .rtf, .xls, .xlsx, .ods, .csv, .tsv, .png, .jpg, .jpeg, .webp, .gif, .heic, .tif, .tiff, .txt, .md, .markdown, .html, .htm, .xml, .json, .eml, .msg), 50 MB max each: any other type is refused, including archives (unzip them and send their files) and binaries such as SPSS files; 50 sources at most per survey; link valid 2 hours. Uploading does not rewrite the context: call generate_survey_context once the files are in.
create_dashboard
ChatGPTCreate a new, empty results dashboard on a survey and return its token. Fill it afterwards with add_dashboard_card. To build a dashboard from scratch, read get_results_map first: it lists the questions and their card_id, which is what the cards refer to.
create_grid
ChatGPTCreates a grid on an AI Chat study and returns it with the link to the Grids page. A respondent grid compares respondents one by one (respondent_ids, the respondent_id of get_individual_data, and/or every respondent of population_tokens); a population grid compares saved populations (population_tokens, from list_populations) and gets a comparative summary. Then ask a question with ask_grid_question. To question every respondent at once, skip this and use the default grid.
create_population
ChatGPTSaves a population on a survey, as the dashboards do: a name and filters in the dashboards format, { "<question id>": { "<answer code>": true } } (question ids and codes from list_survey_questions). When a population with the same filters already exists, it is returned instead with existing: true.
create_review_thread
ChatGPTOpen a new review thread — a comment on the questionnaire, e.g. after reviewing it — anchored to a specific card via card_token (from get_survey_map), or survey-wide when omitted. The thread is authored by the authenticated user and flagged « via <assistant> » (posted_via); mention_ids notify specific users. Use reply_to_review_thread for follow-ups in an existing thread instead of opening a duplicate.
create_section
ChatGPTInsert a new section in the questionnaire. previous_section_token positions it right after that section; omit it to append at the end. The new section starts empty — move existing cards into it with move_card, or create new ones with create_card using a previous_card_token inside it.
create_survey
ChatGPTCreate a survey owned by the user, with the same attributes as the platform API. The draft is initialised from the default template: its sections and default message cards (welcome, thanks…) are cloned, so the survey is never empty — inspect it with get_survey_map and list_sections before building the questionnaire with create_section and create_card. Every card belongs to a section. The questionnaire is never generated for you: write its cards yourself.
create_url_parameter_recode
ChatGPTTurn a URL parameter carried by the survey link into an analysable question — the usual way to split results by traffic source, wave, store or any tag passed at recruitment. Give categories to group the raw values (each with the exact values it absorbs), or omit them entirely to keep the parameter verbatim as an open question. The answers of an analysis recode are computed asynchronously after the card is created, so re-read the survey a moment later to see them; a programming recode is computed as each respondent passes. The response states the origin retained and where the recode is visible — repeat it to the user. Nothing is persisted while the card is invalid: the platform answers with the validation messages, so fix them and retry.
delete_card
ChatGPTRemove a card from the questionnaire, along with its questions. The platform refuses when the card is a recode used by the weighting setup (the error explains it). Deletion is immediate and not reversible — double-check the card_token against get_survey_map before calling.
delete_dashboard_card
ChatGPTRemove one card from a results dashboard. The remaining cards keep their positions, which leaves a gap in the numbering — harmless, they stay in the same order. Only the dashboard card is removed, never the survey question.
delete_grid
ChatGPTDeletes a grid with its rows, its columns and every answer they hold — not reversible, double-check the grid token first. The default "All respondents" grid cannot be deleted.
delete_section
ChatGPTRemove a section from the questionnaire. Its cards are not deleted: they are reassigned to the previous section. The platform refuses to delete the first section.
delete_survey_context_source
ChatGPTDelete one source (uploaded file or pasted text) of the survey context; the file itself is deleted too. The context text is left as is: call generate_survey_context to rewrite it without that source. Source tokens come from get_survey_context.
describe_analysis_card_type
ChatGPTReturn the fields an analysis card reads, split between content (what it computes on: question ids, answer codes, settings) and options (how it is displayed: population, heading, color, width), with the eligible question types, the defaults and a worked example. Call it before add_dashboard_card or update_dashboard_card on an analysis card: the dashboard renders from these fields only, so a wrong id gives an empty card, never an error. Question ids and codes come from get_results_map.
describe_card_type
ChatGPTReturn the fields a card type accepts in specs, reflected live from the platform models — call it before create_card or update_card when unsure of the expected shape. Pick the type with list_card_types first. Localized fields are keyed by the survey locale tokens. A field with a default takes that value when create_card omits it — send it only to change it.
generate_survey_context
ChatGPTHave Episto AI (re)write the survey context from the questionnaire and every source of the survey (files added through create_context_upload_link, texts added with add_survey_context_text). It REPLACES the current text, manual edits included. The generation is asynchronous: this call returns at once with status "generating"; call get_survey_context again after about a minute (longer with many new sources: each source is read on its own first, five at a time, and a source already read is reused), and keep waiting while the status is still "generating". "done" means the new text is in content, "failed" that Episto AI could not write it. A second call while one runs starts nothing.
get_aggregated_data
ChatGPTUse when the user asks for survey results as figures: the distribution of answers per question, optionally broken down by respondent segments shown side by side. Question ids, answer codes for segment conditions and saved population tokens come from get_results_map. When get_results_map says weighted: true, these figures are weighted: say so the first time you give figures in a conversation, not in every answer, with the product word ("pondéré" in French, "Weighted" in English). Never call them weighted or raw when the map does not say it.
get_completion_filters
ChatGPTUse before filtering a completion funnel by campaign, audience or date range. Returns the values get_survey_completion accepts for one survey: master campaigns, campaigns and audiences (each as {value, label}, pass the value), and the first and last participation dates.
get_dashboard
ChatGPTRead one results dashboard: its name, options, the saved populations it shows (populations, besides "All"), and the ordered list of its cards with their id, card_type and position. Read it before changing anything, so positions and card ids are the current ones.
get_grid
ChatGPTOne grid with its rows and its columns. An AI question column carries one cell per row, each with its status (pending, streaming, done, failed), its answer and the citations quoting the interview it comes from (only with include_citations). This is the tool to call again after ask_grid_question until every cell is done or failed. A cell names its subject by respondent_id (the respondent_id of get_individual_data) or by search_group_id, whose token and name are on the matching row (search_group_token, search_group_name). Rows come by pages of limit from offset, with the cells of those rows; total_rows gives the full count. On a population grid, summaries holds the comparative summary of each question.
get_individual_data
ChatGPTUse when the user asks to read individual answers, open-ended verbatims or AI Chat interviews, or to analyse themes across respondents. Returns a flat table with one row per respondent, keyed by a pseudonymous respondent_id. Each row may carry: per-question answers (categorical labels, raw text for open questions, numeric codes for scales); for an AI Chat study, a summary with focus-tagged highlights and focus_{index} interview transcripts (respondent turns prefixed R:, interviewer turns I:); and a boolean column per segment in segment_columns. Provide at least one of include_summaries, question_ids, or focus_ids. Question ids and focus_index values come from get_results_map.
get_programming_check
ChatGPTGet the report of the fake respondents of a survey (see run_programming_check), waiting up to a minute while they are generated. status "none" means no test ran yet. Once "done", issues lists what will not work, each on a card, with what to change and why: error must be fixed before going live; warning must be checked, it may be intended; info explains the limits of the test. profiles gives how the respondents of each profile ended, loi_minutes the estimated length, questions the number of questions answered. Report the errors first, one line per card, with the change to make.
get_results_map
ChatGPTUse before reading survey results, to learn which questions can be analysed and the identifiers the results tools take. Returns every analysable question with its id, title, type and answer codes; for an AI Chat study, the interview objectives with their focus_index; the saved populations with their token and size; the collection period; and weighted, true when the results of this survey are weighted. Personal-data questions and media questions (email, postal code, image, audio, video) are excluded.
get_scripting_guidelines
ChatGPTThe team's rules for writing and reviewing a questionnaire. effective is the list to follow for the survey (or the general rules without one): the general rules, then the rules of the account — when two contradict each other, the account rule wins. lint_rules are the checks the platform runs itself after every card save: each finding opens its own review thread (lint_code in list_review_threads), never blocking a save. review_method is how to review a questionnaire: follow it whenever you are asked for a review. Read the guidelines before creating cards, and never open a review thread for an issue a check already covers.
get_survey
ChatGPTUse when the user asks about the setup of one survey: status, study type, languages (locales, with the tokens update_survey needs), targeted audience (age, gender, countries), fieldwork targets with their sample size, median completion time and the validation errors of the questionnaire. Identified by its token. To give the link respondents answer on, call get_survey_links.
get_survey_completion
ChatGPTUse when the user asks where participants leave a survey: the completion funnel card by card, with where they screen out (disqualified by an answer) and where they drop out (abandon). Returns net_completion, net_screenout and overall_completion as rates between 0 and 1, plus per-card counts (n = participants who saw the card, n_screenout, n_drop, rates on the same 0-1 scale) and the screenout answers of each card. Returns {"status":"unavailable","reason":…} when the funnel cannot be computed: "no_participation" (nobody started yet), "no_match" (the filters keep nobody) or "not_tracked" (participants exist but their path card by card was not recorded, as in older studies; the fieldwork counts of get_survey_progress still hold). Explain that reason in plain words, without quoting the code, and never guess another one. Optional filters restrict the population; get_completion_filters lists the valid campaign and audience values.
get_survey_context
ChatGPTRead the context of a survey: the brief (Markdown) that states its background, objectives, target, brands and competitors, hypotheses, previous results and other notes, each statement followed by its "[source]", and ends with a "Sources" map saying what each uploaded file or pasted text contains — read it to know which source holds what. The context describes the study, it is not what respondents answered: results come from the results tools only. When the answer needs more than the context says, ask that source a question with ask_survey_context_source. The list of sources, with their tokens, comes with it. Call it before analysing results or reviewing a questionnaire when the objectives of the study matter to the answer. status is "generating" while a generation runs (see generate_survey_context); content is null when nobody wrote nor generated it yet.
get_survey_links
ChatGPTBuild the links respondents use to answer a survey, the ones the backoffice "Links" page hands out. A link is specific to a country and a language, and optionally to a chat page (the branded skin the questionnaire is served under). The test link replays the questionnaire without recording a respondent; the live link collects real answers, so only share it once the survey is ready. Without arguments it returns the default combination the backoffice preselects, along with every country, language and page available for this survey.
get_survey_map
ChatGPTThe working map of a survey: ordered sections, and ordered cards (token, type, name, section_token) each with its question ids and its answers (code, token, title), plus the existing targets (with their audience conditions) and quotas. It carries the identifiers the target and quota tools take: the survey_id and target tokens for targets, the question_id and answer codes for quotas. Identifier semantics: quota answers use the answer code (1-based position), target condition values use the answer token; NPS/rating/slider conditions take integer values and "999" means skipped. Call it again whenever the user asks about the questionnaire: earlier answers in the conversation may be stale.
get_survey_progress
ChatGPTUse when the user asks how data collection is going: completed versus targeted respondents overall, then per target (audience segment) with the state of every quota. Each quota lists the tracked answer, its current count (n_total) and its expected count (target). quota_type "follow_up" marks quotas tracked for information only, without a hard target.
insert_standard_cards
ChatGPTInsert a block of Episto standard cards (GDPR notice, gender, age, postal code, CSP, income, satisfaction, opt-in, thanks, goodbye, AI consent) exactly as the editor does: the cards, their recodes and their conditions, translated to the survey locales. Prefer it to rebuilding these questions with create_card. type is a standard type from list_card_types (category standard). Placement works as in create_card. The platform answers 422 when a card of the block is already in the survey (same name) — rename or delete the existing one first.
list_analysis_card_types
ChatGPTList every analysis card of the results dashboards (crosstab, KPI, funnel, TURF, key drivers, map, word cloud…) with what each one shows and when to use it. Read it when the user asks for an analysis a plain question chart cannot give, to pick the sub_type; then describe_analysis_card_type for the exact content and options before add_dashboard_card.
list_card_types
ChatGPTList every card type with its category (question, message, operation) and a one-line description of what it does — use it to pick the right type for create_card, then describe_card_type for the specs it expects. The standard category lists the blocks of Episto standard cards, inserted with insert_standard_cards. A type with creatable: false can appear in existing questionnaires, but create_card refuses it for this user.
list_contact_attributes
ChatGPTThe contact attributes available on the mailing lists of a survey, which is what create_contact_attribute_recode recodes. open attributes hold free text and can only be kept verbatim; single attributes map each attribute name to the values actually seen, so those values are the ones a category can absorb. Call this before creating a contact attribute recode rather than guessing a name — a name that matches nothing produces an empty recode without any error.
list_dashboards
ChatGPTList the results dashboards (views) of a survey, with their token and name. Use the token with get_dashboard to read a dashboard, or with the card tools to change its content.
list_grids
ChatGPTGrids are the analysis tables built over the AI Chat interviews of a survey (AI Chat studies only). A respondent grid holds one row per respondent, a population grid one row per saved population. Every survey also has a default grid named "All respondents", addressed by the token default: it covers every respondent of the survey but stores no row, so its row_count is null. Each grid comes back with its AI questions; read the answers with get_grid.
list_populations
ChatGPTThe populations saved on a survey, the same as the dashboards: token, name, color and filters (question id → selected answer codes). Their tokens are the rows of a population grid.
list_review_threads
ChatGPTAll review threads (comments left on the questionnaire) of a survey, oldest first: status ("open" or "resolved"), the card they are anchored to (card_token + card_name), author, resolver, and every comment of the discussion (body, author, mention_ids, and posted_via naming the AI assistant the author posted it through, null when written by hand). Use it to review outstanding feedback; then resolve_review_thread closes a handled thread and reply_to_review_thread answers when something needs clarification. Comment author ids can be used as mention_ids in replies.
list_sections
ChatGPTOrdered sections of the questionnaire (token, name, position). Every card lives in a section; use these tokens with create_section, update_section, delete_section, move_section and move_card.
list_survey_questions
ChatGPTUse when the user asks what a survey measures, how the questionnaire is structured or how many questions it has. Returns every question, in order, with its id, card_token, name, title, question type and answer choices (code to label), recodes included; personal-data and admin-only questions are omitted. question_count is the number of questions the product shows, one per question card: give that number when asked how many questions a survey has. questions is finer: a matrix has one row per item and a ranking adds generated rows, so never count them. Call it again whenever the user asks about the questionnaire: earlier answers in the conversation may be stale.
list_surveys
ChatGPTUse when the user asks which surveys (studies) exist in their Episto account, how many there are, or needs the token of a survey before calling another tool. Returns 20 surveys per page, most recent first, with name, status, study type, account name and respondent counts. total counts every matching survey across all pages: when asked how many surveys there are, answer with total (never the length of one page) and name the account(s) listed in accounts. Filters can be combined: name, status, account. "My surveys" means every survey the user can access: leave mine_only off unless the user explicitly asks for the surveys they created themselves; with it, total_accessible is how many surveys the user can access in all, to mention alongside.
move_card
ChatGPTReposition an existing card. Give exactly one target: previous_card_token (the card lands right after it, in its section unless section_token says otherwise), or position 'first' / 'last' (top or bottom of section_token — by default the first section for 'first', i.e. the very top of the questionnaire, and the last section for 'last'). section_token alone means 'last' of that section. A programming recode is computed when the respondent passes it, so it must stay after every question it reads: a move that would break that is refused with the recodes concerned — pass move_dependent_recodes to move them right after their last source in the same call. The response gives the placement actually observed after the move; report that, never the requested one. Fetch card tokens from get_survey_map and section tokens from list_sections.
move_section
ChatGPTReposition a section: it lands right after previous_section_token (omit it to move the section first). The cards follow their section — their positions are realigned to the new section order.
refresh_grid
ChatGPTRegenerates the answers of population rows and the comparative summaries marked outdated by get_grid (their population changed since they were written). Without ids, every outdated row and summary of the grid is refreshed. The current answers and their citations are erased and replaced, with no way to restore them. The answers regenerate in the background, one model call per cell: call get_grid until they are done.
reply_to_review_thread
ChatGPTPost a comment in a review thread — e.g. ask a clarifying question when the feedback cannot be handled as is. The comment is authored by the authenticated user and flagged « via <assistant> » (posted_via). Replying to a resolved thread REOPENS it. mention_ids notify specific users (use the author ids from list_review_threads).
resolve_review_thread
ChatGPTMark a review thread as resolved once its feedback has been handled — the resolution is attributed to the authenticated user and the backoffice updates live. Pass reopen: true to reopen a resolved thread instead. Thread ids come from list_review_threads.
run_programming_check
ChatGPTWalk the questionnaire with fake respondents to find what will not work before going live. The platform creates or refreshes coverage profiles from the programming — one completing the survey, one per target, one per screen-out, one per answer a display condition depends on, plus random respondents — then regenerates the respondents of every active fake respondent profile of the survey, the ones created by hand included. The survey must be in draft or review status. The answer waits up to a minute for the report (read it as described in get_programming_check); when status is still "running", call get_programming_check a bit later.
update_card
ChatGPTEdit an existing card: only the fields you send change (merge semantics), but an array field (e.g. answers) is replaced whole — send the complete new array and keep the existing token on every element that stays, otherwise it is replaced by a generated one and the conditions referencing it break. Elements you add without a token get a generated one. Fetch the current shape from get_survey_map first. The platform validates the result and answers 422 with the validation messages — nothing is persisted while errors remain. The card type cannot be changed. section_token moves the card to another section of the same survey. Do not change the categories of a recode here: its answers and ranges would fall out of sync.
update_dashboard
ChatGPTRename an existing results dashboard, and/or set the saved populations it shows (the population pills on top of it, compared side by side by every question card). A card drawn on one population (options.population, content.compare_population) must use one the dashboard shows: add it here first. Its cards are left untouched.
update_dashboard_card
ChatGPTChange an existing dashboard card: its title or wording (content), its display options, or its position. A section title is content.title, a text block is content.text; the heading of a question or analysis card is options.custom_name_title. On an analysis card, content holds what it computes on and options how it is shown: describe_analysis_card_type gives the fields of its sub_type (keep sub_type in content). content and options each replace the whole object, so send back the keys you want to keep — read get_dashboard first. To change a chart, set options.chart_type to one of its listed values (e.g. horizontal bars = "bar_clustered"), keeping the other current options. Moving a card with position does not renumber the others; use it to swap two known positions.
update_grid
ChatGPTRenames a grid, adds or removes its rows and columns, and reorders them; answers are never generated here (use ask_grid_question). Rows: add_respondent_ids (the respondent_id of get_individual_data) and/or add_population_tokens (from list_populations: the population itself on a population grid, its respondents on a respondent grid). Columns: add_question_ids (question ids from list_survey_questions, respondent grids only). Removing takes the row and column ids of get_grid, and deletes the answers they hold; reordering takes every id in the wanted order. The AI questions a grid already asks are answered for every new row, one model call each. The default "All respondents" grid cannot be renamed and holds every respondent: row changes are refused on it.
update_section
ChatGPTRename a section of the questionnaire. Only the name changes — use move_section to reposition it.
update_survey
ChatGPTEdit the survey record itself — only the fields you send change. Changing status drives the platform lifecycle ('draft', 'review', 'live', 'complete'); setting 'complete' triggers the completion processing. locales replaces the whole array: send every locale the survey keeps with its token from get_survey, since a locale sent without its token is created anew and the texts of the one it replaces are lost. The questionnaire is edited with the card and section tools, not here.
update_survey_context
ChatGPTReplace the text of the survey context with the given Markdown. Keep the "## " sections the context already uses (Background, Objectives, Target, Brands and competitors, Hypotheses, Previous results, Other notes, Sources), the "[source]" citations after each statement, and send the WHOLE text: it overwrites the current one. Read it first with get_survey_context to edit it rather than rewrite it.
get_aggregated_data
Claudeget_completion_filters
Claudeget_individual_data
Claudeget_results_map
Claudeget_survey
Claudeget_survey_completion
Claudeget_survey_progress
Claudelist_survey_questions
Claudelist_surveys
Claude