# Archee Docs: every page

> Archee Studio is a hosted engineering workspace for machine design and power transmission: cited calculations from Vietnamese engineering textbooks, TCVN drawing checks and DXF/DWG drawings, with no CAD software on the user's machine. Archee MCP exposes it to coding agents as two tools, `search` and `execute`, at https://mcp.archee.studio/mcp (Streamable HTTP; OAuth sign-in or a personal access token).

---

# Introduction

> What Archee Studio is, what Archee MCP adds, and where to start.

Source: https://docs.archee.studio/start/introduction

Archee Studio is a hosted workspace for mechanical design: machine elements and power transmission. You describe the design in the web app, upload your work and hand tasks to Archee's agent. Everything runs on Archee's servers, so you install nothing and need no CAD software.

## What you get

- **Cited calculations.** Belts, gears, shafts, keys, bearings, couplings and housings, each step tied to the textbook table or formula it came from.
- **A Knowledge Base.** Search Vietnamese engineering textbooks and standards and get the page that answers, not a summary of it.
- **Drawings.** Build, inspect, render and convert DXF and DWG drawings that open cleanly in AutoCAD.
- **TCVN checks.** Check a drawing against TCVN drafting rules and get findings you can act on.
- **Deliverables.** Package the assembly drawing, the detail drawing and the report for submission.

## Two ways in

| | Archee Studio | Archee MCP |
| --- | --- | --- |
| Where | The web app at [app.archee.studio](https://app.archee.studio) | Your coding agent: Claude Code, Codex, Cursor, Claude Desktop |
| How | Chat, upload, review | The agent writes short Python programs against the Archee SDK |
| Billing | Credits | The same credits |

Both use the same account, projects and files.

## Where to start

- [Quickstart](https://docs.archee.studio/start/quickstart.md) Your first cited calculation in five minutes.
- [Set up Archee MCP](https://docs.archee.studio/mcp/setup.md) Connect your coding agent.
- [Plans and credits](https://docs.archee.studio/start/plans-and-credits.md) What each plan includes.

---

# Quickstart

> Connect your agent to Archee and get a cited engineering calculation in five minutes.

Source: https://docs.archee.studio/start/quickstart

## The one-line way

Paste this into your coding agent and it sets everything up, then asks you to sign in:

```text
Set up Archee MCP for me by following https://docs.archee.studio/start/agent-setup.md
```

## By hand

1. **Get an account.** Sign in at [app.archee.studio](https://app.archee.studio). Archee MCP needs a plan that includes it; see [Plans and credits](https://docs.archee.studio/start/plans-and-credits.md).

2. **Add Archee to your agent.** In Claude Code:

   ```bash
   claude mcp add --transport http --scope user archee https://mcp.archee.studio/mcp
   ```

   Other clients are on [Set up Archee MCP](https://docs.archee.studio/mcp/setup.md).

3. **Sign in once.** Run `/mcp` in Claude Code and choose `archee`; your browser opens. Approve the consent page and return to the agent.

4. **Ask for an outcome.** For example:

   > Use Archee to calculate a V-belt drive for 8.15 kW at 1455 rpm with ratio 2.25, section B, and tell me which textbook tables it used.

## What happens

Your agent calls `search` to find the SDK functions it needs, then sends one `execute` program that composes them, roughly:

```python
import archee

belt = archee.calc.run("vbelt", P1_kW=8.152, n1_rpm=1455.0, u=2.252, section="B",
                       d1_mm=180.0, eps_slip=0.01, load_class="light", motor_group="I", shifts=2)
belt
```

The result carries the values, the checks that passed or failed, and the citations behind them. The call is charged to your credits; the result shows how much.

## Next

- [Search and execute](https://docs.archee.studio/mcp/tools.md): how the two tools work.
- [Example programs](https://docs.archee.studio/mcp/examples.md): drawings, checks and deliverables.

---

# Let your agent set it up

> One line for your agent; it installs Archee MCP in your client and tells you when to sign in.

Source: https://docs.archee.studio/start/agent-setup

Paste this into Claude Code, Codex, Cursor or any coding agent:

```text
Set up Archee MCP for me by following https://docs.archee.studio/start/agent-setup.md
```

Your agent adds Archee to its own configuration, then asks you to sign in once in the browser. That is the whole setup.

---

## Instructions for the agent

You are setting up Archee MCP for the user. Follow these steps in order, run each command yourself, and stop at the first error to report it.

- **Server name:** `archee`
- **URL:** `https://mcp.archee.studio/mcp` (Streamable HTTP)
- **Sign-in:** OAuth in the browser; the client discovers it from the server. No token is needed unless the user gives you one.

### 1. Find the client you run in

Use the first that applies: you are Claude Code if the `claude` command exists and you are running inside it; Codex if `~/.codex/` exists and you are Codex; Cursor if you are running inside Cursor. If you cannot tell, ask the user which client they use.

### 2. Add the server

Skip this step if a server named `archee` is already configured with the same URL.

**Claude Code.** Add it for every project of this user:

```bash
claude mcp get archee || claude mcp add --transport http --scope user archee https://mcp.archee.studio/mcp
```

**Codex.**

```bash
codex mcp get archee || codex mcp add archee --url https://mcp.archee.studio/mcp
```

**Cursor.** Merge this into `~/.cursor/mcp.json`, keeping every existing server:

```json
{ "mcpServers": { "archee": { "url": "https://mcp.archee.studio/mcp" } } }
```

**Claude Desktop.** It has no configuration file for remote servers. Tell the user: open Settings → Connectors → Add custom connector, name `Archee`, URL `https://mcp.archee.studio/mcp`.

**Any other client.** Add a remote MCP server named `archee` with the URL above, following that client's documentation.

**With a token.** Only if the user gave you a personal access token (`arch_pat_…`): store it in the environment variable `ARCHEE_TOKEN`, never in a file in a repository, and send it as `Authorization: Bearer $ARCHEE_TOKEN` (Claude Code: add `--header "Authorization: Bearer $ARCHEE_TOKEN"`; Codex: add `--bearer-token-env-var ARCHEE_TOKEN`).

### 3. Hand over to the user

Tell the user exactly this, adapted to their client:

- **Claude Code:** "Archee is added. Run `/mcp`, choose `archee` and sign in in the browser."
- **Codex:** "Archee is added. Run `codex mcp login archee` and sign in in the browser."
- **Cursor and others:** "Archee is added. Restart the client; it opens the browser to sign in on first use."

### 4. Check it

After the user has signed in, call the `search` tool with `query="vbelt"`. If it returns function stubs, reply: "Archee MCP is ready." If it fails, use [Troubleshooting](https://docs.archee.studio/mcp/troubleshooting.md) and report the error and its `call_id`.

Do not run `execute` as a test: it is charged in credits.

---

# Plans and credits

> Which plans include Archee MCP, how credits work and where to see your usage.

Source: https://docs.archee.studio/start/plans-and-credits

## Plans

Archee MCP is part of the paid and team plans. The student plan does not include it at launch. Your plan also sets which [scopes](https://docs.archee.studio/mcp/authentication.md#scopes) a connection can hold; for example, packaging deliverables needs a plan that includes `deliver`.

If your plan changes, connected agents follow it: a downgrade takes effect within about a minute, without reconnecting.

## Credits

Archee Studio and Archee MCP draw on one credit balance. These are metered:

- sandbox time, per second of a running program;
- Knowledge Base calls;
- TCVN checks;
- deliverable packages.

`search` is free. The current rates are listed on the Billing page in the web app; they are set by the Archee team and can change without a client update.

## Before and after a call

Before a program runs, Archee reserves enough credits to cover its time limit. When it finishes, you pay only what it used and the rest is released. If your balance cannot cover the reservation, nothing runs and the error says how much is needed. See [Limits and credits](https://docs.archee.studio/mcp/limits.md).

## Your usage

The Billing page shows usage per day, per item and per token, so you can see which agent or token spent what.

---

# Set up Archee MCP

> Connect Claude Code, Codex, Cursor or Claude Desktop to Archee in about two minutes.

Source: https://docs.archee.studio/mcp/setup

> **Fastest:** tell your agent `Set up Archee MCP for me by following https://docs.archee.studio/start/agent-setup.md` and it does the steps below itself. See [Let your agent set it up](https://docs.archee.studio/start/agent-setup.md).

> **Server URL:** `https://mcp.archee.studio/mcp` (Streamable HTTP). You need an Archee account on a plan that includes MCP; see [Plans and credits](https://docs.archee.studio/start/plans-and-credits.md).

## Connect your client

1. **Add the server.** Pick your client.

   ```bash
   # Claude Code
   claude mcp add --transport http --scope user archee https://mcp.archee.studio/mcp
   ```

   ```bash
   # Codex
   codex mcp add archee --url https://mcp.archee.studio/mcp
   ```

   ```json
   // Cursor: ~/.cursor/mcp.json
   { "mcpServers": { "archee": { "url": "https://mcp.archee.studio/mcp" } } }
   ```

   ```text
   Claude Desktop: Settings → Connectors → Add custom connector
   Name: Archee
   URL:  https://mcp.archee.studio/mcp
   ```

2. **Sign in.** In Claude Code run `/mcp` and choose `archee`; in Codex run `codex mcp login archee`; other clients open the browser on first use. Sign in to Archee and approve the consent page; the client keeps and refreshes its own tokens.

3. **Check it.** Ask your agent: "List the Archee calculations you can run." It should call `search` and answer from the results.

## Use a token instead

For CI, scripts or a client without browser sign-in, use a personal access token. Create one in the web app under **Settings → Connected apps and tokens**, then pass it as a bearer header:

```bash
# Claude Code
export ARCHEE_TOKEN=arch_pat_...
claude mcp add --transport http archee https://mcp.archee.studio/mcp \
  --header "Authorization: Bearer $ARCHEE_TOKEN"
```

```toml
# Codex: ~/.codex/config.toml
[mcp_servers.archee]
url = "https://mcp.archee.studio/mcp"
bearer_token_env_var = "ARCHEE_TOKEN"
```

```json
// Cursor: ~/.cursor/mcp.json
{ "mcpServers": { "archee": {
  "url": "https://mcp.archee.studio/mcp",
  "headers": { "Authorization": "Bearer ${env:ARCHEE_TOKEN}" } } } }
```

Client configuration formats change. If one of these stops working, follow your client's own remote-MCP documentation with the same URL and `Authorization: Bearer` header.

## Disconnect

Revoke the connected app or the token under **Settings → Connected apps and tokens**. The next request from that client is refused. See [Sign-in and tokens](https://docs.archee.studio/mcp/authentication.md).

## Next

- [Search and execute](https://docs.archee.studio/mcp/tools.md): what the agent can call.
- [Troubleshooting](https://docs.archee.studio/mcp/troubleshooting.md): `401`, `403` and other errors.

---

# Sign-in and tokens

> Browser sign-in, personal access tokens, scopes and how to revoke access.

Source: https://docs.archee.studio/mcp/authentication

Archee MCP accepts two kinds of credentials. Both act as you, inside your plan, and both can be revoked at any time.

| Method | Best for | Lifetime |
| --- | --- | --- |
| Browser sign-in (OAuth) | Interactive clients: Claude Code, Cursor, Claude Desktop | Refreshes itself; the refresh token lasts 30 days from its last use |
| Personal access token `arch_pat_…` | CI, scripts, headless agents | 7, 30 or 90 days, chosen when you create it |

## Browser sign-in

Clients that support remote MCP servers discover Archee's sign-in automatically. On first use the client opens your browser; you sign in, see which scopes the client asks for and approve. The client then holds short-lived access tokens and refreshes them on its own.

Archee uses OAuth 2.1 with PKCE. A refresh token can be used once: if a used one comes back, Archee treats it as stolen and ends that whole sign-in.

## Personal access tokens

1. In the web app open **Settings → Connected apps and tokens**.
2. Create a token, pick its scopes and an expiry.
3. Copy it. It is shown once and cannot be recovered; create a new one if you lose it.

Keep tokens in an environment variable or a secret store, never in a repository.

## Scopes

A connection holds only the scopes you approved, and never more than your plan allows.

| Scope | Allows |
| --- | --- |
| `mcp:search` | Finding SDK functions with `search` |
| `mcp:execute` | Running programs with `execute` |
| `files:write` | Uploading files to a project |
| `kb:read` | Knowledge Base search and pages |
| `verify` | TCVN drawing checks |
| `deliver` | Packaging deliverables |
| `agent:run` | Handing long work to Archee's agent |

A client that asks for no scope gets `mcp:search` and `mcp:execute`. A program that calls a function outside its scopes gets a `ScopeDenied` error naming the missing scope.

## Revoke access

Under **Settings → Connected apps and tokens**, revoke a connected app or a token. The next request it makes is refused. Revoking a connected app also ends its refresh tokens, so it cannot sign itself back in without you.

If your plan stops including MCP, every connection stops working within about a minute and works again if the plan is restored.

---

# Search and execute

> The two tools Archee MCP exposes, their inputs and what a result contains.

Source: https://docs.archee.studio/mcp/tools

Archee MCP has two tools. Instead of one tool per function, the agent finds functions with `search` and composes them in one Python program with `execute`. Fewer round trips, and the agent can loop, branch and combine results like any program.

## search

Finds SDK functions and types by what you need. It is free.

| Input | Type | Meaning |
| --- | --- | --- |
| `query` | string | A function name, a calculation or a standard, in English or Vietnamese |
| `limit` | integer, 1–20 | How many entries to return (default 5) |
| `kind` | optional | Restrict to one kind of entry |

It returns the matching Python stubs: signatures, parameter units and docstrings, exactly what the program will call.

```text
search(query="bearing life", limit=3)
```

## execute

Runs a Python program in a fresh sandbox with `import archee` available.

| Input | Type | Meaning |
| --- | --- | --- |
| `code` | string, ≤ 50 KB | The program. Its last expression, or an explicit `return`, is the result |
| `project` | optional string | Project slug or id; omit for your scratch project |
| `timeout_s` | integer, 1–120 | Wall-clock limit in seconds (default 30) |

```python
import archee

key = archee.standards.lookup_key(shaft_d=40)
bearing = archee.standards.lookup_bearing(d=40, kind="deep_groove", series="light")
{"key": key, "bearing": bearing}
```

## The result

| Field | Meaning |
| --- | --- |
| `ok` | Whether the program finished without an error |
| `result` | The value of the last expression, as JSON |
| `stdout` | What the program printed |
| `error` | The error type and message when `ok` is false |
| `files_changed` | Files the program wrote in the project |
| `evidence_ids` | Citations behind the values |
| `credits` | What the call cost |
| `duration_ms` | How long it ran |
| `call_id` | Quote this when you ask for help |

Long output is cut in the middle: the head and the tail are kept with a marker between them. Return less, or write large data to a file and return its link.

## The sandbox

Each program runs in its own sandbox with no network and no access to your computer or to other users. It reads and writes only the selected project's files. When the time limit passes the program is stopped; for longer work use `archee.agent.run` and poll `archee.runs.get` in a later call.

---

# Python SDK

> The archee modules available inside execute, with their main functions.

Source: https://docs.archee.studio/mcp/sdk

Inside `execute`, `import archee` gives the modules below. This page lists the main functions; `search` returns the full signature, units and docstring of each one, and is always current.

## calc

Cited engineering calculations. Each result carries its values, checks and the textbook sources behind them.

| Function | Does |
| --- | --- |
| `calc.list()` | Every calculation available |
| `calc.describe(name)` | Inputs, units and outputs of one calculation |
| `calc.run(name, **inputs)` | Run a calculation by name, for example `"vbelt"` |
| `calc.run_bearing_rolling(...)`, `calc.run_belt_life(...)`, … | Typed shortcuts for individual calculations |

## standards

Catalogue lookups.

| Function | Does |
| --- | --- |
| `standards.lookup_bearing(d, kind, series)` | A rolling bearing for a bore |
| `standards.list_bearings(d, kind)` | Every bearing that fits a bore |
| `standards.lookup_key(shaft_d)` | The parallel key for a shaft diameter |
| `standards.lookup_fastener(nominal_d)` | Bolt and nut dimensions, for example `"M12"` |
| `standards.housing_proportions(a_w)` | Gearbox housing proportions from the centre distance |

## draft

DXF and DWG drawings.

| Function | Does |
| --- | --- |
| `draft.inspect(drawing, …)` | Entities, layers and blocks, paged |
| `draft.render(drawing, output, …)` | A PNG of the drawing or a region of it |
| `draft.check(drawing, design, kind)` | Drawing findings against the design record |
| `draft.convert(to, input, output)` | DXF ↔ DWG |
| `draft.detail(design, out_dir, part_type)` | A shaft or gear detail drawing from the design |
| `draft.build(...)`, `draft.edit(...)` | Build or change drawings with a builder script |

## kb

The Knowledge Base of engineering textbooks and standards.

| Function | Does |
| --- | --- |
| `kb.search(query, limit)` | Passages with their source, printed page and score |
| `kb.page(source, page)` | One page of a source |

## verify and deliver

| Function | Does |
| --- | --- |
| `verify.check(path, standard="TCVN")` | TCVN findings for a drawing |
| `deliver.package(kind)` | A submit-ready `a0_assembly`, `a3_detail` or `report` package |

## files and project

| Function | Does |
| --- | --- |
| `files.upload(name, data)` | Store bytes or text in the project |
| `files.list(prefix)` | Files with size and SHA-256 |
| `files.link(path)` | A signed download link that expires |
| `project.info()` | The current project |
| `project.design(path)` | The design record, or one value in it |
| `project.design_set(path, value, expected_revision)` | Change one design value safely |

## agent and runs

| Function | Does |
| --- | --- |
| `agent.run(prompt)` | Hand long work to Archee's agent; returns a run id |
| `runs.get(run_id)` | The state and output of a run |

## errors

Every SDK error derives from `archee.errors.ArcheeError`:

| Error | When |
| --- | --- |
| `BudgetExceeded` | The program spent its credit allowance |
| `ScopeDenied` | The connection lacks a scope the call needs |
| `PlanDenied` | Your plan does not include the feature |
| `NotFound`, `Invalid` | A missing file or a bad argument |
| `Unavailable`, `BridgeTimeout` | A service was busy or slow; retry |
| `Internal` | Something failed on Archee's side; quote the `call_id` |

---

# Example programs

> Copy-ready execute programs for calculations, citations, drawings and deliverables.

Source: https://docs.archee.studio/mcp/examples

Each program is one `execute` call. Ask your agent for the outcome and it will write programs like these; you can also send them yourself.

## A cited calculation

```python
import archee

belt = archee.calc.run("vbelt", P1_kW=8.152, n1_rpm=1455.0, u=2.252, section="B",
                       d1_mm=180.0, eps_slip=0.01, load_class="light", motor_group="I", shifts=2)
belt
```

Not sure of the inputs? `archee.calc.describe("vbelt")` lists them with units.

## Find the source

```python
import archee

hits = archee.kb.search("bảng chọn tiết diện đai thang", limit=3)
[{"source": h.source, "page": h.printed_page, "text": h.text[:200]} for h in hits]
```

## Pick parts for a shaft

```python
import archee

d = 40
{
    "key": archee.standards.lookup_key(shaft_d=d),
    "bearings": archee.standards.list_bearings(d=d, kind="deep_groove"),
}
```

## Check a drawing and share it

Upload the drawing in the web app first, or with `archee.files.upload`.

```python
import archee

report = archee.verify.check("sheets/detail-a3.dxf", standard="TCVN")
link = archee.files.link("sheets/detail-a3.dxf")
{"passed": report.passed, "findings": [f.message for f in report.findings], "download": link.url}
```

## Render a drawing

```python
import archee

archee.draft.render("sheets/assembly-a0.dxf", "renders/assembly.png", dpi=150)
archee.files.link("renders/assembly.png").url
```

## Change a design value safely

```python
import archee

doc = archee.project.design("shafts.slow.d_mm")
archee.project.design_set("shafts.slow.d_mm", 45, expected_revision=doc.revision)
```

If someone changed the design since you read it, the write is refused instead of overwriting their change; read it again and retry.

## Hand off long work

```python
import archee

run = archee.agent.run("Redraw the A3 detail of the slow shaft with the new diameter.")
run.run_id
```

Then, in a later call:

```python
import archee
archee.runs.get("RUN_ID")
```

---

# Limits and credits

> Size, time and rate limits for Archee MCP, and how a call is charged.

Source: https://docs.archee.studio/mcp/limits

## Limits

| Limit | Value |
| --- | --- |
| Program size | 50 KB |
| Time per program | 1–120 s (default 30 s) |
| Output | 20,000 characters of stdout, 12,000 of result; the head and tail are kept |
| Requests | 60 per minute per user, 30 per minute per token |
| Programs at once | 2 per user |
| Upload | 25 MB per file |
| Files read | 200 MB per file |

When you hit a rate or concurrency limit, the error says how many seconds to wait.

## How a call is charged

Everything is metered in the same credits as the web app: sandbox time per second, Knowledge Base calls, TCVN checks and deliverable packages. `search` is free.

1. **Reserve.** Before the program starts, Archee reserves credits for its full time limit plus an allowance for the SDK calls it may make.
2. **Run.** If the program spends its allowance, the next paid call raises `BudgetExceeded`, which the program can catch.
3. **Settle.** You pay what the program used; the rest of the reservation is released. The result's `credits` field shows the amount.

If your balance cannot cover the reservation, nothing runs and the error says how much is needed. A lower `timeout_s` means a smaller reservation.

A call is charged once. If a client retries a call that was already charged, the retry is refused instead of charged again.

## Rates

The current rates are on the Billing page in the web app, with your usage per day, item and token. Rates are set by the Archee team and can change without a client update.

---

# Troubleshooting

> What each Archee MCP error means and how to fix it.

Source: https://docs.archee.studio/mcp/troubleshooting

Every result carries a `call_id`. Quote it when you ask for help.

## Connecting

| You see | Do this |
| --- | --- |
| `401` with a browser prompt | Sign in when the client opens Archee. |
| `401` with a token | Check the token was copied whole and has not expired or been revoked. |
| The client cannot reach the server | Use the full URL including the path: `https://mcp.archee.studio/mcp`. |
| "MCP access is not included in your plan" | Upgrade on the Billing page. |
| The browser never opens | Your client may not support remote sign-in; use a [personal access token](https://docs.archee.studio/mcp/authentication.md#personal-access-tokens). |

## Calling

| You see | Do this |
| --- | --- |
| `403 insufficient_scope` or `ScopeDenied` | The connection lacks a scope, for example `deliver`. Reconnect and approve it, or create a token with it. Some scopes need a plan that includes them. |
| "Not enough credits" | Top up on the Billing page; the message says how much the program needs. |
| `BudgetExceeded` | The program spent its allowance. Split the work or raise `timeout_s`. |
| `[timed out after N s]` | Raise `timeout_s` (up to 120), or move long work to `archee.agent.run`. |
| "MCP sandboxes in use" or a rate limit | Wait the number of seconds shown and retry. |
| `duplicate_call` | The client resent a call that already ran. Send a new call. |
| Results look cut off | Return less; write large data to a file and return its link. |
| `Unavailable` or `BridgeTimeout` | A service was busy. Retry after a few seconds. |

## Still stuck

Write to the Archee team from [archee.studio](https://archee.studio) with the `call_id`, the client you use and what you expected.

---

# Security and privacy

> How Archee keeps programs, files and credentials apart, and what you control.

Source: https://docs.archee.studio/reference/security

## Programs

- Every `execute` program runs in its own sandbox, created for that call and discarded after it.
- The sandbox has no network. It cannot reach the internet, your computer or other users.
- It sees only the files of the project you chose. Paths that try to leave the project, including links planted inside it, are refused.
- Time and output are capped; see [Limits and credits](https://docs.archee.studio/mcp/limits.md).

## Files

- Files live in your project on Archee's servers and are visible only to your account.
- Downloads are signed links that expire.
- Design changes are checked against the revision you read, so two agents cannot silently overwrite each other.

## Credentials

- Browser sign-in uses OAuth 2.1 with PKCE. You see and approve the scopes a client asks for.
- Refresh tokens are single-use. A reused one ends the whole sign-in.
- Personal access tokens are shown once and expire after 7, 30 or 90 days.
- Every connection holds only its approved scopes and never more than your plan allows.
- Revoking a connected app or token takes effect on its next request.

## What you control

| You want to | Do this |
| --- | --- |
| See what is connected | Settings → Connected apps and tokens |
| Cut off a client | Revoke it there |
| See what was spent | The Billing page, per day, item and token |
| Limit an automation | Give its token only the scopes it needs, with a short expiry |

## Report a problem

If you find a security issue, write to the Archee team from [archee.studio](https://archee.studio) before sharing it publicly.

---

# FAQ

> Short answers to common questions about Archee Studio and Archee MCP.

Source: https://docs.archee.studio/reference/faq

## Do I need AutoCAD?

No. Archee produces DXF and DWG on its servers. You need AutoCAD or another CAD application only to open the drawings yourself.

## Do I need to install anything?

No, only your agent. Archee MCP is a remote server at `https://mcp.archee.studio/mcp`; nothing runs on your computer.

## Which agents work?

Any client that supports remote MCP servers over Streamable HTTP: Claude Code, Codex, Cursor and Claude Desktop are covered in [Set up Archee MCP](https://docs.archee.studio/mcp/setup.md).

## Is the web app the same as MCP?

They share your account, projects, files and credits. The web app is for chatting, uploading and reviewing; MCP lets your coding agent call the same tools from programs.

## Why two tools instead of many?

An agent that writes one program can combine many functions in a single call, with loops and conditions, instead of one round trip per function. `search` keeps the full SDK out of the agent's context until it needs a part of it.

## Which language are the textbooks in?

Mostly Vietnamese. You can search in English or Vietnamese; results keep the original text and page.

## Which standard do drawing checks use?

TCVN, the Vietnamese national standards for technical drawings.

## How do I read these docs as an agent?

Every page is also Markdown at the same address plus `.md`. [llms.txt](https://docs.archee.studio/llms.txt) lists them all, and [llms-full.txt](https://docs.archee.studio/llms-full.txt) has every page in one file.