# app.doxai.ch — Full LLM Reference > app.doxai.ch is DoxAI's multilingual CV and resume builder. It provides a public web app and an authenticated AI gateway with namespaced MCP tools and resources for app discovery, account billing, CV editing, resume persistence, validation, compilation, templates, job retrieval, and the DoxAI job-application workflow. This file is an integration overview, not a replacement for live schemas. Use the [developer documentation](https://app.doxai.ch/developers) for endpoint examples and call MCP `tools/list` before invoking tools. ## Canonical resources - Product: https://app.doxai.ch/ - Developer documentation: https://app.doxai.ch/developers - Pricing: https://app.doxai.ch/pricing (per language: https://app.doxai.ch/en/pricing, https://app.doxai.ch/fr/pricing, https://app.doxai.ch/de/pricing) - MCP endpoint: https://app.doxai.ch/v1/mcp - OpenAPI: https://app.doxai.ch/openapi.json - Short LLM index: https://app.doxai.ch/llms.txt ## Authentication and authorization API and MCP requests operate on the authenticated user's account. Personal API tokens are managed from the account page and are sent as Bearer credentials: ```http Authorization: Bearer ``` For MCP, use either a personal API token with the `mcp:connect` scope or an OAuth access token issued through the server's protected-resource discovery flow. Direct resume endpoints use `resume:generate`; other direct API endpoints document their own required scopes. Claude and other remote MCP clients: add a custom connector named DoxAI with the endpoint URL; sign-in uses OAuth, with no token to copy. The connector works on the Free plan with the same limits as the web app. Keep credentials out of URLs, query parameters, request bodies, CV fields, logs, and generated documents. Use only tokens supplied for app.doxai.ch, and do not expose tool results belonging to one user to another user. ## MCP transport The primary remote MCP endpoint is `https://app.doxai.ch/v1/mcp`. It uses JSON-RPC over streamable HTTP. Supported protocol versions, newest first, are `2025-11-25`, `2025-06-18`, `2025-03-26`, and `2024-11-05`. The server negotiates a version during `initialize`, falls back to the newest version for an unsupported requested version, and treats a missing streamable HTTP protocol header as `2025-03-26` for compatibility. 1. Send `initialize` by POST with a supported MCP protocol version. 2. Retain the `MCP-Session-Id` and negotiated `MCP-Protocol-Version`; send both headers on subsequent streamable HTTP requests. 3. Send `notifications/initialized` when required by the client flow. 4. Call `tools/list`; its names, schemas, titles, and annotations are authoritative for the negotiated protocol version. Structured output fields are available with `2025-11-25` and `2025-06-18`; legacy versions omit them. 5. Call `resources/list` and `resources/read` when resource-oriented context is preferable to a tool call. 6. Call a selected tool with `tools/call`. 7. Close an unused session with DELETE. The compatibility endpoints `/v1/mcp/tools` and `/v1/mcp/tools/call` provide REST-style list and call wrappers. The namespaced catalog mode is `namespaced_tools`. Do not infer arguments from a tool name. Follow the schema returned by `tools/list`, preserve structured tool errors, and retry only when an error indicates that retrying is safe. ## MCP tool catalog ### App and account tools - `app_get_info` — Read-only. Returns public app, MCP protocol, template, and documentation metadata. It takes no arguments. - `account_get_billing_status` — Read-only. Returns the DoxAI plan (free / plus / pro) and the quota the billed job-application tools spend, as the account page shows it: day and week percentages with their resets on Plus/Pro, remaining action counts on free. It also returns `ai_settings`: the pinned model (null = the catalog default, named in `effective_model`), the default effort and the models the plan may use (`models`: id, name, provider, eco), which are the ids the `model` argument of `quick_apply` / `generate_application` accepts (free cannot choose). Never amounts or prices. It takes no arguments. ### Resume read-only tools - `resume_validate_cv_data` — Validates and best-effort normalizes `cv_data` without creating a job or compiling a PDF. - `resume_get_create_job_example` — Returns a canonical `resume_create_job` payload. It accepts an optional template. - `resume_get_job` — Returns one authenticated-user-owned job and a short-lived PDF download URL when an artifact is available. The compiled CV comes back as `input_summary`; `include_input: true` returns the full `input_payload`. It requires `job_id`. - `resume_get_pdf` — Returns a direct short-lived signed PDF URL for one authenticated-user-owned job. While the job is queued or running it fails with the retryable `resume_pdf_not_ready` (`retry_after_seconds`); a failed or canceled job fails with `resume_job_failed`. It requires `job_id` and accepts an optional `expires_in_seconds`. - `resume_list_templates` — Returns supported templates, colors, fonts, sizes, preview URLs, and billing metadata. It accepts an optional `locale`. - `resume_list_jobs` — Returns the authenticated user's newest resume jobs. Its optional positive integer `limit` defaults to 20 and is capped at 100. ### Resume state-changing tool - `resume_create_job` — Creates an asynchronous resume compilation job. It requires a stable `request_id` and a `cv_data` object. Put the template in `cv_data.template`, not in a top-level `template` argument. Only call `resume_create_job` when the user has asked to create or compile a resume. It can store personal CV data (compiling the PDF itself is free). Prefer `resume_validate_cv_data` first and use a stable unique `request_id` so an exact retry can be treated idempotently. ### CV persistence tools - `cv_list_resumes` — Read-only. Lists the authenticated user's resumes with identifiers, template, status, and update time. - `cv_get_resume` — Read-only. Returns one authenticated-user-owned resume, including its data snapshot. - `cv_create_resume` — Creates a resume row with a template, CV data snapshot, and optional status (default `draft`). - `cv_update_resume` — Updates supplied mutable fields on one authenticated-user-owned resume. `data_snapshot` replaces the whole stored CV (same canonical shape as `cv_data`). Writes return `normalization`: the language kept or detected from the text and every change the normalizer made. The `cv_` tools store CV documents edited outside an application (the Studio library) and the `resume_` tools only render CV data to PDF; an application's own CV and letter go through the `v2.*` tools below. Resume write tools are state-changing. Use them only when the user asked to persist the change, and prefer a read after a write when the exact stored state matters. ### DoxAI job-application tools These cover the job-application workflow rather than CV rendering. - `get_profile` — Read-only. Returns the authenticated user's global career profile and quota status. Optional `compact: true` retains current editable content, revision and entry ids while omitting memory, fact provenance/history and administrative metadata. Default/false preserves the full response. - `patch_profile_entries` — State-changing, never billed. Atomic batch: `base_revision` and 1–100 `operations` with `op` (add/update/remove), `collection` (experiences/education/skill_groups/free_sections/free_section_items), `id` for updates/removals, and typed `value` for additions/updates. Nested items require `section_id`. Adds append with generated ids; updates retain omitted fields, other entries and order. Section updates cannot replace items. Returns the compact saved profile and new revision. Unknown/foreign ids return `profile_entry_not_found`; stale revision returns `profile_revision_conflict`. Read again and reconcile before retrying. See tools/list for field schemas and bounds. - `update_profile` — State-changing, never billed. Updates the global profile with partial `display_name`, `contact`, `constraints` and/or `knowledge` fields. Read the profile first, then pass its `revision` as `base_revision` (0 if no profile exists). Omitted fields are preserved and nested objects merge; supplied arrays replace the entire list, so keep existing entry ids and all entries that should remain. An empty array clears a list; an empty string clears a text field. Server-owned memory, fact provenance and daily quota settings cannot be edited here. On `profile_revision_conflict`, read the latest profile and review the edits before retrying. Returns the saved profile with its new revision. - `list_opportunities` — Read-only. Lists tracked job opportunities, newest first, as summaries without the posting text (optional `limit`, default 20, max 100; `total` gives the full count). - `get_opportunity` — Read-only. Returns one opportunity, including its analysis when one exists and `analysis_freshness` (whether the profile changed since the analysis). The posting text comes as `posting_excerpt`; `include_posting_text: true` returns the full stored text. It requires `opportunity_id`. - `list_applications` — Read-only. Lists the authenticated user's applications as summaries (company, role, status, `has_cv`, `has_cover_letter`, apply URL, dates; optional `limit`, default 20, max 100; `total` gives the full count). No letter text or form answers. - `get_application` — Read-only. Returns one application with its cover letter, CV reference and review report, plus `review_points` (the review's stretch lines with their ids). It requires `application_id`. - `search_jobs` — Read-only, not billed, no model call. Searches DoxAI's job-ad index: ads from employers across Switzerland (all 26 cantons), collected nightly, not exhaustive. Filters: `q` (≤ 120 chars), `cantons` (two-letter codes), `workload_min` / `workload_max` (percent), `posted_within_days` (1, 7 or 30), `sort` (`recent` or `relevance`, relevance only with `q`), `page` (1–500), `per_page` (1–50, default 20); no contract-type, remote or salary filter. Each ad has its `job_id`, the employer's original posting `url` and `opportunity_id` when it is already in the user's pipeline; `total` and canton `facets` come with the page. - `get_job` — Read-only, not billed. One ad of the index by `job_id` with its full description (Markdown when available; `max_chars` default 20000, max 60000, `truncated` says whether it was cut), category, seniority, `url`, `doxai_url` and `opportunity_id`. An expired ad returns `not_found`. - `recommend_jobs` — Read-only, not billed. Ranks index ads against `cv_text` when given (200–20,000 characters, used for matching only and not stored), else against the user's stored profile (experience, education, skills, projects, achievements; never contact details, job-search criteria or remembered preferences), best first, `count` 1–20 (default 10), optional `cantons`. No score is returned. An empty profile returns no ads and `profile_empty: true`. - `create_opportunity` — State-changing, not billed. Captures a job posting from a URL and/or its text, or from a `job_id` of the job-ad index (its text, URL, employer and title then come from the index). Re-sending a tracked URL returns the existing opportunity with `duplicate: true`. - `analyze_opportunity` — State-changing and billed. Scores one opportunity against the user's profile. It requires `opportunity_id` and a stable `request_id`. - `create_application` — State-changing, not billed. Opens the application for one opportunity (idempotent per opportunity). It requires `opportunity_id`. - `generate_application` — State-changing and billed. Drafts the tailored CV and (unless `include_letter: false`) the cover letter of one application, then runs the same review as `quick_apply` (fact check, revision, layout check) and returns the `review_points` to confirm with the user. Reuses the stored analysis and reports `analysis_stale`; `refresh_analysis: true` re-runs a stale one first. The result names the model that drafted the CV (`model`); Plus and Pro can pass `model` (an id from `account_get_billing_status`) to draft with another model for this call only, without changing the account default. It requires `application_id` and a stable `request_id`. - `generate_letter` — State-changing and billed. Drafts or redrafts only the cover letter of one application (optional `tone`: sober, warm, direct; `language`: fr, en, de; `address_constraints`). It requires `application_id` and a stable `request_id`. - `get_application_cv_pdf` — Free. Compiles the application's tailored CV to PDF and returns a signed download link (`download_url`, `expires_at`, default and maximum 1 hour). Compiles are rate-limited per user (`rate_limited`, retryable). - `get_application_letter` — Free. Exports the stored cover letter as `pdf` or `docx` and returns a signed download link. - `resolve_review_points` — State-changing, not billed. Records the user's keep / soften / drop answers to the review points. It records the decision only; it does not rewrite the document. - `update_application_status` — State-changing, not billed. Records the status the user reached (forward only: preparing → ready → sent → interview / offer / rejected). `sent` means the user sent it themselves. - `quick_apply` — State-changing and billed. One-shot: captures a posting, analyzes it, opens an application and drafts the tailored CV in a single call, reserving quota step by step. Prefer it when the user just wants the tailored CV; use the separate tools when they need to read the analysis before deciding. The result names the model that drafted the CV (`model`); Plus and Pro can pass `model` (an id from `account_get_billing_status`) for this call only. It requires a URL and/or the posting text plus a stable `request_id`. To find a posting first: `search_jobs` or `recommend_jobs` → `get_job` → `create_opportunity` with its `job_id` → `analyze_opportunity` / `create_application` + `generate_application` (or `quick_apply` with the posting URL). When job search is not enabled on a deployment these tools return `jobs_unavailable`; `jobs_service_unavailable` is retryable. Without an account: `search_jobs` (`per_page` ≤ 20, `page` ≤ 5), `get_job` (`max_chars` ≤ 8000) and `recommend_jobs` with `cv_text` (`count` ≤ 10) work over MCP with no sign-in, as do `app_get_info` and `resume_list_templates`. Every other tool answers HTTP 401 with a `WWW-Authenticate` challenge, so the client asks the user to sign in to DoxAI. To finish an application: read it with `get_application`, settle its review points with the user, get the CV link with `get_application_cv_pdf`, draft the letter with `generate_letter` and get its link with `get_application_letter`; the user sends the application, then `update_application_status` records it. `analyze_opportunity`, `generate_application`, `generate_letter` and `quick_apply` consume the account's DoxAI quota. They reserve budget before the model call and settle the real cost afterwards, so a stable `request_id` makes an exact retry idempotent instead of double-charging. Their results include `quota_usage`: the quota after the call and what it consumed (percentage points of each window on Plus/Pro, action counts on free). When quota is exhausted they return a `quota_exceeded` error rather than partial output. `quick_apply` and `generate_application` run for minutes: send `params._meta.progressToken` for per-step progress. They are kept under the client's tool-call time limit, so optional steps (company research, review, revision, layout corrections) may be cut short and are then listed in `cutForTime` (`quick_apply`) or `cut_for_time` (`generate_application`); after a timeout, retry with the same `request_id` to get the stored result. **DoxAI drafts application materials but never sends or submits them.** No tool applies to a job, emails a recruiter, or submits a form on the user's behalf. Generated documents are drafts for the user to review and submit themselves. ## MCP resources - `cv://templates` — Static supported resume-template definitions. - `cv://resumes` — An index of resume resources belonging to the authenticated user. - `cv://resumes/{id}` — The stored JSON data snapshot for one authenticated-user-owned resume. - `cv://profile` — The authenticated user's DoxAI career profile and quota status as JSON (same data as `get_profile`). Resource reads are user-scoped. A resume URI for another account is not a way to bypass ownership checks. ## CV data and templates Supported template identifiers are currently: - `original` - `picture` - `harvard` - `business` - `sidebar` Call `resume_list_templates` for the current catalog and `resume_get_create_job_example` for a canonical payload. The source of truth for the selected template is `cv_data.template`. At minimum, canonical identity data includes `first_name` and `last_name`; use the live schema for all other fields and section shapes. CV payloads and generated PDFs can contain sensitive personal data. Preserve only user-provided facts, do not invent credentials or qualifications, and do not place secrets in CV content. ## Content boundaries for generated material Everything generated for a user — tailored CVs, cover letters, profile edits, interview stories — may assert only facts already present in the user's profile and CV state, or that the user stated directly. Reformulate a posting's keywords into the user's real experience; never fabricate new claims, never inflate tool familiarity into authorship, and never invent or round up metrics. ## Billing and side effects Validation, discovery, billing-status, template-listing, and job-reading tools are read-only. Resume compilation is free for every plan and template, but it stores the user's CV data. Before creating a job: 1. Read the current tool schema. 2. Validate the CV data. 3. Ensure the user requested the compilation. 4. Submit one stable `request_id` and retain the returned job ID. ## Resume job lifecycle Resume compilation is asynchronous. A job can be `queued`, `running`, `succeeded`, `failed`, or `canceled`. Use `resume_get_job` to poll one known job or `resume_list_jobs` to discover recent jobs. A successful job may include a short-lived signed PDF URL. Treat signed URLs as sensitive, do not publish them, and fetch or share them only as the user requests. ## Direct resume HTTP API The developer documentation also describes direct Bearer-token endpoints: - `POST /v1/resume/jobs` — Create an asynchronous job. This is state-changing (free). - `GET /v1/resume/jobs/:jobId` — Read job status. - `GET /v1/resume/jobs/:jobId/pdf` — Download the authenticated user's PDF artifact. The same privacy, billing, validation, and idempotency guidance applies to direct API calls. ## In-browser tools (WebMCP) Public pages register a small read-only WebMCP tool set through `navigator.modelContext` for browser agents. Those tools run in the visitor's own session and never carry a personal API token. Use the remote MCP endpoint above for authenticated automation. ## Public web pages and locales Public product routes are available in English (`/en`), French (`/fr`), and German (`/de`). The landing and pricing pages are served at each of these localized URLs (`/fr`, `/fr/pricing`…), and `/` and `/pricing` redirect to them in the visitor's negotiated language. Localized developer, feedback, terms, privacy, cookie, and legal notice pages use the same language prefix. Unprefixed public routes negotiate or redirect to a supported locale. - EN: https://app.doxai.ch/en - FR: https://app.doxai.ch/fr - DE: https://app.doxai.ch/de - Feedback: https://app.doxai.ch/en/contact/suggest-an-improvement - Terms: https://app.doxai.ch/en/contact/terms-of-service - Privacy: https://app.doxai.ch/en/contact/privacy-policy - Cookies: https://app.doxai.ch/en/contact/cookie-policy - Legal notice: https://app.doxai.ch/en/contact/legal-notice ## Service boundaries The public managed chat endpoints are retired. Do not assume that a header or mode switch re-enables managed chat. For agent workflows, use the documented resume HTTP endpoints or the authenticated MCP tool catalog. Contracts are evolving. When this file, cached knowledge, and a live response disagree, prefer the live `tools/list` schema, structured error details, and current developer documentation.