Azquo MCP ServerVerifiedFeatured

@Azquo Holdings Ltd

Homepage Documentation

Basic information

Transport

Streamable HTTP

Authentication

OAuth

About Azquo MCP Server

Exact, shared memory for AI agents: a hierarchical database where totals always add up, every write is attributed to the agent and person behind it, and any figure traces back to its source file. Agents create databases, import spreadsheets and documents, query with AQL, run Excel reports and audit any value - several agents and people can work in the same database at once.

#database #memory #multi-agent #audit #finance #excel #provenance

Connection details

https://data.azquo.ai/mcp

Setup

claude mcp add azquo --transport http https://data.azquo.ai/mcp

Azquo MCP Server tools

Add parent → child relations between names. Idempotent: existing links stay; new ones are added. With createMissing=true (default) names are auto-created if not found. Returns: applied, alreadyLinked, namesCreated (the names that didn't exist before), namesResolved (every child in input order with its resolved id — use to chain into edit_name_attributes). ═══ PROVENANCE — required on every write ═══ source: origin reference (file/URL/document/short note). Lands in the audit trail. agent: your AI agent name (e.g. "Claude"). Lands in the audit trail.

Write a 2D region of values into an Azquo database using the same AQL grammar as query_aql. AQL reference: https://www.azquo.com/connect/#aql Mirrors the read shape — rowHeadings × columnHeadings × context — and adds a 2D `values` array. The cell at values[r][c] is anchored to the union of rowHeadings[r] + columnHeadings[c] + context, exactly as a read at the same coordinates would resolve. Two modes, distinguished by options.createNames: Case 1 — TRANSACTIONAL find-or-create. Caller supplies options.rowSet + options.rowLanguage (and/or columnSet + columnLanguage) + createNames: true. Unresolved row/column headings are FIND-OR-CREATED under the target set with the language attribute set. Arrow form: rowSet = "A->B" puts new names into B as a child of A (chain is auto-created if missing). Use for: importing new transactions, customers, or any entity whose ID column is the row heading. Case 2 — MULTI-FACETED all-or-nothing (default; createNames: false). Every heading must resolve to an existing name. Any miss is fatal — no values land. Use for: writing into a pre-structured region where the names are already known. Structure-only mode: omit `values` (or pass []). The call resolves the headings, find-or-creates names if createNames=true, but writes no values. Equivalent to declaring hierarchy. For date columns where the duplicate-name trap applies, use options.rowLanguage = "date" (bare attribute name, no "language" prefix). rowLanguage / columnLanguage always take the literal attribute name verbatim. createNames and ignoreHeadingErrors are m

Explain where one value in a query_aql result came from: the provenance (which import, file, user or write, and when) of every stored value behind the cell, and the calculation if the cell is a function or a total. Read-only. Use it when a number looks wrong or the user asks "where does this figure come from?". For the history of a name's attributes and set membership use name_history instead. Call it with exactly the rowHeadings, columnHeadings and context you passed to query_aql (the query is re-run to locate the cell), plus the zero-based row and col of the cell in that result's rows array. Example: after query_aql returned rows[2][0] = 1250, pass the same three arrays with row 2, col 0. Returns headline (the cell and its headings), function (the formula, when calculated) and auditForDisplayList - one entry per provenance: user, method, name (the source, e.g. the file), date, context and the values it supplied (capped at 1000). Returns {message: "cell not found"} when row/col is outside the result. Earlier, overwritten values show only while the database records history (history_settings).

Copy azquo_skills (the Azquo usage-skills database) from data.azquo.ai into the current business, so a local or offline Azquo has its own copy. Call it again later to refresh. ASK THE USER FIRST: confirm 'Copy azquo_skills from data.azquo.ai into <business>?' and wait for a yes. A database already called by the target name is REPLACED, and any local edits to it are lost, so say so when list_databases shows one already there. Use current_business to name the target in that question. No key is needed: the server fetches with the public read-only key.

Copy one database from the shared Azquo library into the current business, with its reports, import templates and uploaded file types. ASK THE USER FIRST: confirm 'Copy <database> into <business>?' and wait for a yes before calling this — never copy speculatively or as a side effect of a browse request. Use current_business to name the target in that question, and list_library for the available database names. Nothing is ever overwritten: if the name is already taken in the target business the copy lands as 'name_1', 'name_2', and so on. Always tell the user the `target` name from the result, which is the name the database is actually stored under and may differ from the one they asked for — database names are sanitised, so spaces become underscores and punctuation is dropped.

Create a new, empty Azquo database in the current business (see current_business). Use it to start a new model from scratch; to start from a ready-made one use copy_from_library, and to experiment on an existing database use try_on_copy. Needs an administrator or developer; the creator becomes its owner. The name is cleaned: spaces become underscores and anything other than letters, digits and underscores is dropped ("Sales 2026!" becomes Sales_2026). Fails with database_create_failed if a database of that name already exists in the business - check list_databases first. databaseServerId: usually left out - the database then goes on the default server, the one the admin site's New database offers first. Give it only to choose a particular server; an unknown id fails with unknown_databaseServerId and the error lists the valid ids. Returns the new database record: id, name (as cleaned), persistenceName, databaseServerId and its counts (all zero). Next steps are usually apply_structure or import_file, then persist_database.

Get a link where the USER uploads documents (Word, PDF, Excel, PowerPoint, anything) to keep with a database. Use this whenever a file should be stored in Azquo - NEVER base64 a file into a tool call. Give the user the url; they open it in a browser and drop the files. The server keeps each original (downloadable later) and makes a Markdown copy of Word/PDF/Excel/PowerPoint/HTML/text for you to read with read_document. Pass nameId to attach them to a name, typically a Meta info note: each upload adds a short attribute DOCUMENT <id> to it (IMAGE <id> for a png/jpg/gif/webp/bmp picture) - the file itself is never put in the name. The link lasts 30 minutes and takes any number of files. Afterwards call list_documents to see what arrived. FILES YOU MADE YOURSELF (e.g. a .docx built in your code sandbox): do not make the user download and re-upload them. If your sandbox can reach this server, POST them straight to the link with the returned `curlCommand` (multipart, one -F files=@... per file); the reply is JSON with each document's id. The link is the only credential - no API key. If the request cannot connect, the sandbox's network access does not include this server: tell the user it can be allowed in Claude.ai's code-execution network settings, and meanwhile give them the url.

Return the currently effective business and user for this MCP session, and whether an acting-as override is in effect. Use before any destructive action.

Permanently delete an Azquo database by name, with all its names, values and history. NOT REVERSIBLE - there is no restore, and its backups are deleted too. Do not call without the user explicitly asking for this database to be deleted; confirm the name and the business (current_business) with them first. To remove a few names use delete_name (restorable with restore_name); to test changes safely use try_on_copy. Also removed: reports left linked to no other database or user, its import template if no other database uses it, its upload history, pending uploads and uploaded source files. Reports and templates shared with other databases are kept. Needs an administrator of the business, or the developer who owns the database; the name must be exact (list_databases). Errors database_not_found for an unknown name. Returns {deleted: true, name} - also when a developer who does not own it is refused silently, so confirm with list_databases afterwards.

Permanently delete one import template (the workbook of rules that interprets incoming data files) and its file on disk. NOT REVERSIBLE - there is no restore; read it first with read_workbook if its rules may be wanted again. Do not delete without the user asking for it. Get the id from list_import_templates. Administrators only, and only templates in the current business. A database that used the template is not updated and still points at the deleted id, so imports into it lose those rules; list_database_sheets shows which template each database uses. Returns {deleted: true, id}. That is returned even when nothing was removed (unknown id, other business, or not an administrator), so call list_import_templates afterwards to confirm it has gone.

Delete a name from the database. Its values are deleted with it, as are the documents and images uploaded to it with create_upload_link (the response's documentsDeleted says how many) - those cannot be brought back. The name itself can: restore_name returns it, with its attributes, sets and children, as a new name (find it with list_deleted_names). Looks up by integer nameId — the id returned in apply_structure's namesResolved, or surfaced by describe_set / describe_query. Returns 404 if no name matches the id. ═══ PROVENANCE — required on every write ═══ source: origin reference (why this name is being deleted — usually a ticket, note, or upstream document). Lands in the audit trail. agent: your AI agent name (e.g. "Claude"). Lands in the audit trail.

Permanently delete one online report (an Excel report users run in Azquo): its workbook file, its menu entries, its external data requests and its schedules. NOT REVERSIBLE - unlike delete_name there is no restore; read it first with read_workbook if its layout may be wanted again. Do not delete without the user asking for it. The databases the report showed are not touched. Get the id from list_reports. Needs an administrator, or the developer who uploaded the report. Errors report_not_found when the id is not one of the reports list_reports shows you. Returns {deleted: true, id}.

Get an overview of an Azquo database: top-level sets with child counts, available attributes, and the 'meta information' subtree (semantic descriptions stored back into the database). Use this as the first step when exploring an unfamiliar database — one call gives more context than multiple AQL probes.

Resolve a name-query expression and return the matched names with full details: parents, attributes (including AI Text bodies and any other attribute values), and child counts. The query is a name expression as understood by the Azquo NameQueryParser. Common forms: - An exact display name (e.g. "State + Territory derivation") - A set verb in POSTFIX position after a backtick-quoted name: `API endpoints` children `Florida Coverages` parents `Sales` from 2024 to 2025 Set verbs are ALWAYS postfix. The prefix English form "children of X" is NOT valid AQL — the parser will try to resolve "of" as a name and fail. - Set algebra on backtick-quoted names: `Florida` * `Coverages` (intersection), `A` + `B` (union), `A` - `B` (difference) Read-only: "edit:..." commands and "... as <set>" assignments change the database, so they are refused here - run them through aql_write. A name containing the word "as" must be in backticks. Use this after list_names / describe_set to read attribute values that the other discovery tools don't surface — most importantly the AI Text attribute on a note. Internal/user storage attributes are filtered out by the server. Each resolved entry includes its integer `id` — use it directly to chain into edit_name_attributes or delete_name without a separate lookup. Limit defaults to 50 resolved names per call.

Drill into a named set: returns its child names with child counts, plus the parent path. Use after describe_database to explore a specific set. For meta-info topic reads, pass depth and attributes together to pull the whole topic plus its note bodies in a SINGLE round-trip — e.g. depth=2, attributes=["AI TEXT"] on the "Start here" set of Azquo_Skills returns every Start-here note with its full AI TEXT body. Without these params you would need 1 + N calls (one describe_set plus one describe_query per child). Prefer the combined call for any topic-read.

Surgical attribute edit on an existing name. Each entry in the attributes map sets that attribute on the named name; an empty string value deletes that attribute. Attributes not mentioned in the map are left untouched (this is NOT a wipe-and-replace). Looks up by integer nameId — the id returned in apply_structure's namesResolved, or surfaced by describe_set / describe_query. Returns 404 if no name matches the id — silent no-op is never the result. To rename a name, set its default_display_name attribute via this same call. ═══ PROVENANCE — required on every write ═══ source: where this edit originates — file path, URL, document name, or short note. Lands in the audit trail so the user can return to it. agent: your AI agent name (e.g. "Claude"). Lands in the audit trail so the user can see which AI made the edit.

Fetch the full data for a report, including all regions and current choice values. Reports in Azquo are Excel-based templates with named data regions. Each region contains row/column headings and a 2D array of values. Reports also support 'choices' — named parameters that filter the data (e.g. selecting a business unit, time period, etc). Use it to see what a report shows a user - the figures as laid out in the report. For an ad-hoc question that no report answers, use query_aql; to see a report's formulas and layout rather than its data, use read_workbook. Find reports with list_reports (or list_database_sheets for one database). Pass reportId as either a numeric ID or the report name. The database parameter is required. Any additional choices can be passed as key/value pairs. Choices are SAVED as this user's selections, as when they are picked in the report in a browser, so they also apply to the next run of any report using the same choice. A choice passed as "" clears the saved selection; leave a choice out to keep it as it is. Example choices: { "Month": "Jan-24", "Department": "Sales" } Errors report_not_found when the report does not exist or is not one this user may run, and report_render_failed when the report cannot be calculated.

See or change whether a database records history - value history (audit_cell), name attribute history and set membership history (name_history), all together - and clear it. action: get - current setting, and when it was last switched and cleared (the default) off - stop recording, e.g. while a database is in development and every test import rewrites it on - start recording again (the default for every database) clear - DELETE ALL value, name and set history for the database. NOT REVERSIBLE. Needs confirm: "CLEAR". Typically at the end of development so history starts from real use. Do not clear without the user explicitly asking for it. off/on/clear need an administrator, or the developer who owns the database, and provenance: source: why. agent: your AI agent name (e.g. "Claude").

Import SMALL INLINE DATA into an Azquo database - a base64-encoded blob under `fileContent`. Filename selects the import template. THIS IS THE NARROW ROUTE, NOT THE GENERAL ONE. It base64-transports the file through the agent's context, so it is capped at 256 KB and refuses anything larger. Use it ONLY when the data exists solely in your context and you have no shell. Otherwise: - fetchable by URL -> import_from_url. The SERVER downloads it; nothing crosses your context. - you can run curl -> POST /api/importdata with -F 'file=@...' -F 'database=...' and an X-Azquo-Business header if switching business. ~0.1s for a 57 KB file where this tool takes minutes. See azquo_skills id 813 for the HTTP recipe.

Run SQL against a configured external database connection and import the result into an Azquo database. THE SERVER CONNECTS AND FETCHES - the rows never pass through your context, and the credentials are held server-side, so you never see or supply them. This is the right tool for a business's own internal database. Use list_external_connections to see what is configured; if the source you need is not there, ask an administrator to add it in azquo-admin rather than looking for another route. TWO WAYS TO SAY WHAT THE COLUMNS MEAN, and you need one of them: Supply 'headings' - a tab-separated Azquo header line matching the SELECT order. The source's own column names are discarded. Right for a one-off load. Omit 'headings' - the source's column names are kept as the header row, and the target database's IMPORT TEMPLATE interprets them. Right for a recurring feed, because the mapping then lives server-side instead of being restated on every run. Check list_import_templates for the database first. Imported by the same path as POST /api/importdata, so the usual header grammar applies (see Azquo_Skills > Import). Check 'values adjusted' in the result against what you expected.

Bulk-load a delimited-text or spreadsheet file into a database by URL. THE SERVER DOWNLOADS IT, so the file never passes through your context - this is the right tool for anything large. Same import path as POST /api/importdata: the file needs a self-describing Azquo header row (see Azquo_Skills > Import), and the FILE NAME matters because import instructions are read from it. Returns the same validation summary including lines imported and values adjusted - check that against what you expected, a completed import is not proof of a correct one. Use this instead of import_file for anything beyond a few KB. If the data exists only in your context and nowhere fetchable, either write it to a file and POST /api/importdata with a shell, or fall back to import_file and accept the cost.

List the businesses this MCP session can switch between. Peers are derived from the API key owner's email — one entry per business that email is a member of. Use switch_business to change the active one.

List every Excel workbook associated with one database, grouped into the three kinds Azquo holds: `reports` (online reports users run), `setupSheets` (the workbooks that built the database in the first place), and `importTemplates` (the rules for interpreting incoming data files). Use this to answer 'what spreadsheets come with this database?' — list_reports and list_import_templates are business-wide, whereas this is scoped to the one database named. Counts per group are included, and a group is simply empty when a database has none of that kind.

List all Azquo databases available to the current user. The shared `azquo` business overlays two DBs onto every session: `azquo_skills` (read-only usage skills, always readable) and `azquo_suggestions` (open-write DB where any agent can propose improvements). Overlaid entries carry `overlay: true` plus `readOnly` and `openWrite` flags; local DBs never carry them. Every database in the `azquo_library` training library is also overlaid, read-only, carrying `library: true` — so worked examples can be opened and read in place with describe_database / query_aql, without copying them first. Use copy_from_library only when the user actually wants their own writable copy.

Names that have been deleted, most recent first, with who deleted them and when, how many children they had and which sets they were in. parentId narrows it to names that were in that set. Deleted names keep their ids in the history: pass one to name_history for its last attributes, or restore_name to bring it back. Only deletions made while the database was recording history (history_settings) are listed.

List the documents stored with a database (uploaded via create_upload_link), newest first: id, filename, size, the name they are attached to, and markdownChars - the size of the Markdown copy read_document returns (null when there is none, with markdownNote saying why). Pass nameId for one name's documents. Read-only. Use it to find a document's id before read_document, or to see what source files (PDFs, spreadsheets, notes) back a database. Data files loaded by import_file are not documents and are not listed here. Returns {database, count, documents}, every document at once (no paging). Errors database_not_found when the database does not exist or this user cannot open it.

List the external database connections configured for this business. Use the connection NAME with import_from_query. Credentials are never returned - the server holds them. Connections are set up by an administrator in azquo-admin; if the source you need is not listed, ask for it to be added rather than looking for another route to the data.

List every import template in the current business. An import template is a workbook of rules that tells Azquo how to interpret incoming data files - which columns become which names and values. Read-only, no parameters. Use it to check what templates exist before import_file or import_from_query, or to find the id for delete_import_template. For the template one database uses, use list_database_sheets; to read a template's rules, read_workbook. Returns an array of templates: id, templateName, filename, notes, user (who uploaded it) and dateCreated. Empty when the business has none. Not paginated.

Browse the shared Azquo library of example/demo databases. Returns every catalogue entry in one call with its full description inline, so no follow-up calls are needed to find out what a database contains. Each row carries: name, sector, complexity, features, status, description, and (when the database is uploaded) nameCount and valueCount. Answer questions like 'is there an example with setup sheets?' by reading the description and features text of these rows — there is no separate search endpoint. Copying is a distinct, explicitly-requested step: use copy_from_library, and only when the user has asked for it.

Find names in a database by text match on their display name, when you know roughly what something is called but not where it sits. Read-only. Typical use: resolve an ambiguous label ("Sales" may be a measure in one set and a department in another) to the right nameId before querying or editing it. Neighbours: describe_set walks a set you already know; describe_query resolves an exact name or a name expression and returns full attributes; list_deleted_names finds deleted names (this tool only sees current ones). Pass startsWith for a prefix match or contains for a substring match (startsWith wins if both are given). Matching ignores case. With neither, names are returned unfiltered up to the cap. Example: {database: "Sales", startsWith: "Jan"}. Returns an array of {name, nameId, sets} - sets are the names of the sets it belongs to. At most cardinalityCap names come back (default 500); with a prefix match the cap applies before the prefix filter, so narrow the text if the result looks short.

List the online reports (Excel reports users run in Azquo) the current user can see, across every database in the business. Read-only, no parameters. Use it to find a report's id or name before get_report_data, read_workbook or delete_report. For the reports, setup sheets and import templates of one database use list_database_sheets instead. Who sees what: an administrator sees every report in the business; a developer sees the reports on databases they own; other users see the reports on their menus. Returns an array of reports: id, reportName (with " uploaded by <user>" appended), database (the one it runs against; empty for reports usable with any database, "No database" when unlinked), filename, category, explanation, dateCreated, author. A report linked to several databases appears once for each. With none visible, a single placeholder with id 0 and reportName "No reports found" is returned. Not paginated.

List the user accounts of the current business (see current_business; switch_business to change it). Read-only. Use it to answer who has access and with what role, or to find a user's email or team. For the user behind this MCP session use current_business instead. Who sees what: an administrator gets every user in the business; a master user gets the users they created; anyone else gets an empty list. Returns an array, one entry per user: id, email, name, status (the role, e.g. ADMINISTRATOR, MASTER, DEVELOPER, READONLY), endDate (yyyy-MM-dd, when access expires), selections and team. Passwords are never returned. Not paginated.

History of one name: every earlier version of its attributes (who set them, who replaced them, when), each change to its membership as a set (names added/removed, by whom, when), and - if it has been deleted - its last attributes, parents and children. Works for deleted names too: use list_deleted_names to find their ids. asAt (optional): an ISO date (2026-09-01, meaning the end of that day) or date time (2026-09-01T14:30) - adds the name's attributes and set members as they were then. History is written when the database persists, so an edit made seconds ago may not show yet. A database can have history switched off or cleared (history_settings) - no entries then means none recorded, not no changes. Only attribute changes and set membership are recorded; a name's values have their own history (audit_cell).

Flush pending writes for this database to disk. Edits via edit_name_attributes, apply_structure, AQL edit: primitives etc. are queued in-memory; call this to make them durable.

Query an Azquo database using AQL (Azquo Query Language). AQL reference: https://www.azquo.com/connect/#aql Read-only - this never creates or changes names or values; a heading with an edit: command or an "as" set assignment is refused (use aql_write for those). The main way to get numbers out of a database for an ad-hoc question. Neighbours: aql_write saves values with the same heading model; get_report_data runs an existing report; describe_set / describe_query explore names and sets rather than values; audit_cell explains where one cell of this tool's result came from. AQL works with row headings, column headings, and context — all as nested string arrays, laid out like the heading area of a spreadsheet: each inner array is one row of heading cells, each string one heading. In a stack of headings, a heading on an earlier line applies until another heading or a "." replaces it, so it need not be repeated; the LAST line (the right-hand column, for row headings) is where data anchors and must be filled in every position that should have data. Example — get monthly sales figures by product: rowHeadings: [["`Products` children"]] columnHeadings: [["Sales"], ["Jan", "Feb", "Mar"]] context: [["2024"]] The response contains: rowHeadings — resolved row labels columnHeadings — resolved column labels context — resolved context rows — 2D array of cell values (one entry per [row][col]; raw types: string|number|boolean|null) rowCount, columnCount, truncated — pagination info (options.rowLimit, default 1000) Raise options.rowLimit (0 =

Read a stored document (see list_documents) as Markdown - headings, lists, tables, slides and pages kept. Long documents come a page at a time: 40000 characters by default; when truncated is true, call again with offset = nextOffset. Also returns downloadUrl (valid 60 minutes) for the ORIGINAL file and markdownUrl for the Markdown - give these to the user; do not fetch them yourself. When a document has no Markdown (e.g. an image), markdownNote says why and only the download link is returned.

Read inside one workbook held against a database — a `report`, `importTemplate` or `setupSheet` (use list_database_sheets to see what exists). Called without `sheet` it returns the workbook's shape: every sheet with its extent, and every defined name with its scope and target — for an Azquo workbook the az_ names ARE the model, so start here. Called WITH `sheet` it returns that sheet's cells, showing formulas in preference to computed values. It returns structure and text, NOT the file itself: workbooks run to megabytes, so use the admin's Download button if you want the actual file. Setup sheets and import templates are administrator/developer only; reports follow the caller's report permissions.

Bring back a deleted name (ids from list_deleted_names or name_history). It returns as a NEW name with a new id, its attributes as they were when deleted, put back in the sets it was in and given back its children - where those still exist. Its VALUES ARE NOT RESTORED: deleting a name deletes its values. The response counts what was relinked and what could not be. The restore's provenance records the old id, so the two histories can be followed. ═══ PROVENANCE — required on every write ═══ source: why the name is being restored. agent: your AI agent name (e.g. "Claude").

Switch the active business for subsequent MCP tool calls in this session. The switch is this MCP session's alone: other agents or chats on the same key stay where they are, and a new session starts in the key owner's own business - which a client may open between turns, so check current_business before writing. To run one call in another business without switching, give that call a business argument instead; every tool except this one, list_businesses and current_business takes it. Target must be one the current bearer can reach — call list_businesses first if unsure. Provide exactly one of businessName, businessId, or userId. Writes in the current business are kept when switching; persist_database confirms a batch reached disk (more in azquo_skills id 775).

Try changes on a throwaway copy of a database before making them for real. action=start makes an in-memory copy of the database. From then on EVERY call in this session on that database - reads and writes - goes to the copy, and each result begins 'TRIAL COPY of ...'. Nothing on the copy is ever saved. Check the outcome (query_aql, describe_set, get_report_data ...). Then action=discard to throw the copy away and return to the real database. To keep the changes, make the same calls again after discarding - there is no commit. action=status lists this session's trials. While any trial is on, tools whose effects would reach beyond the copy are refused: imports, create/delete database, delete report/import template, library copies, upload links, and the name history tools. Use it for a risky restructure, a bulk edit:, or a first attempt at an unfamiliar write. A copy holds the whole database in server memory - start warns when the database is large - so discard it as soon as you are done. A copy unused for 2 hours is discarded by the server; calls then fail loudly until you discard the trial here. A trial belongs to this MCP session only; another agent on the same key keeps working on the real database.

Overview

What is Azquo?

Azquo is a hosted hierarchical database that gives AI agents a persistent, exact and auditable place to keep structured data and the decisions behind it. Each fact is stored once, in hierarchies that always total correctly, so an agent retrieves the actual figure, correctly aggregated, rather than text that merely looks relevant.

What agents can do

Create databases and import spreadsheets, CSV files and documents
Build and reorganise hierarchies without designing a schema first
Query with AQL and run Excel reports
Trace any value back to the file, person and date it came from
Rehearse risky changes on a copy, see history, and restore deleted names

Every write is attributed to the agent and the person behind it. Several agents and people can work in the same database at once, and people see the same data live in Microsoft Excel. Notes on what the data means are kept in the database itself, so the next agent starts from what the last one learned.

Connecting

Endpoint: https://data.azquo.ai/mcp (Streamable HTTP)
Sign in with an Azquo login over OAuth (dynamic client registration), or send an API key from the Azquo admin site as Authorization: Bearer <key>
Evaluation accounts on request: https://www.azquo.com/connect/

Hosted by Azquo Holdings Ltd (UK).

Frequently asked questions

What is the Azquo remote MCP server?

The Azquo remote MCP server is a hosted Model Context Protocol endpoint at https://data.azquo.ai/mcp, so AI assistants can connect to it without installing or running anything locally.

How do I connect to the Azquo MCP server?

Add the endpoint https://data.azquo.ai/mcp to any MCP-compatible client such as Claude Code, Cursor, or VS Code. The setup snippets on this page configure each client in one step.

Does the Azquo MCP server require authentication?

Yes. Azquo uses OAuth: the first time you connect, your MCP client opens a browser window to sign in and authorize access, then reuses the credentials for future sessions.

Which transport does the Azquo MCP server use?

Azquo exposes a Streamable HTTP endpoint, the transport used by remote MCP servers and supported by all major MCP clients.

Comments

More remote MCP servers

AOI — Environmental Intelligence

AOI is a commercial environmental-intelligence gateway that gives AI agents programmatic access to 38 real-world intelligence capabilities — climate risk, satellite monitoring, methane detection, water & soil, vegetation

AWS Marketplace

Discover, evaluate, and buy solutions for the cloud

AdLoop Cloud

Hosted AdLoop: Google Ads, Reddit Ads, GA4 and Tag Manager in claude.ai, ChatGPT and more, with a preview before every change.

Adobe Journey Optimizer

Understand and troubleshoot your Journeys and Campaigns

42min

Official 42min MCP server: let Claude, ChatGPT, Cursor or any MCP client manage your meeting scheduling. Check availability, find free slots, book, cancel and reschedule meetings, manage recurring series, secret booking

About Azquo MCP Server

Connection details

Setup

Azquo MCP Server tools

apply_structure

aql_write

audit_cell

copy_azquo_skills

copy_from_library

create_database

create_upload_link

current_business

delete_database

delete_import_template

delete_name

delete_report

describe_database

describe_query

describe_set

edit_name_attributes

get_report_data

history_settings

import_file

import_from_query

import_from_url

list_businesses

list_database_sheets

list_databases

list_deleted_names

list_documents

list_external_connections

list_import_templates

list_library

list_names

list_reports

list_users

name_history

persist_database

query_aql

read_document

read_workbook

restore_name

switch_business

try_on_copy