0203 424 5023 info@azquo.com

Connecting an AI agent to Azquo

Azquo provides an MCP server, so AI agents can create, load, query and audit Azquo databases directly.

The server

Server address: https://data.azquo.ai/mcp

Transport: Streamable HTTP. Listed in the official MCP Registry as ai.azquo/azquo. People see the same data in the browser and in Excel.

What you need

An Azquo account. Evaluation accounts are available on request — contact us at info@azquo.com.

You can then connect in one of two ways:

  • Sign in with your Azquo login (OAuth) — the simplest, used by the Claude app.
  • An API key — for developers and agent frameworks. An administrator issues keys in the Azquo admin site, admin.azquo.ai (Users › Set API key). The key is shown once; keep it safe.

Everything an agent does is attributed to the person whose login or key it uses.

Set it up

Claude (claude.ai and the Claude apps)

  1. Open Settings › Connectors and choose Add custom connector.
  2. Enter the server address https://data.azquo.ai/mcp.
  3. Sign in with your Azquo email and password when asked.

Claude Code

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

Claude Code will ask you to sign in with your Azquo login. To use an API key instead:

claude mcp add --transport http azquo https://data.azquo.ai/mcp --header "Authorization: Bearer YOUR_API_KEY"

Other MCP clients (Cursor, VS Code and others)

Add Azquo to the client’s MCP configuration:

{
  "mcpServers": {
    "azquo": {
      "type": "http",
      "url": "https://data.azquo.ai/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Some clients spell the transport type differently; check your client’s own instructions.

What happens when an agent connects

An agent connecting for the first time is pointed to azquo_skills — a shared database of several hundred notes on working with Azquo, starting from “READ ME FIRST”. It covers importing data, designing hierarchies, querying with AQL, building reports and auditing figures. An agent reads it as it works; nobody needs to train it.

It also finds a library of worked examples it can read or copy: a budget, management accounts, time and expenses, a pivot example, property insurance premiums and a US auto quote.

What the agent learns about your data, it writes back into your own database as notes, for the next agent or person.

What an agent can do

Area Tools (examples)
Explore list_databases, describe_database, describe_set, list_names, describe_query
Query query_aql — exact figures over any hierarchy (how AQL works)
Load data import_file, import_from_url, import_from_query (from a connected database such as Snowflake), create_upload_link
Build structure apply_structure, edit_name_attributes, aql_write
Reports list_reports, get_report_data, read_workbook
Audit audit_cell — trace a figure to its source file and cell; name_history
Safety try_on_copy — rehearse a change on a temporary copy; restore_name; list_deleted_names
Documents create_upload_link, list_documents, read_document

Good first requests

  • “List my Azquo databases and describe the largest one.”
  • “Copy the management accounts example from the library and show me branch profit by month.”
  • “Load this spreadsheet into a new database called sales_test, then check the totals against the file.”
  • “Where did the figure in this cell come from?”

AQL – asking Azquo for figures

AQL (Azquo Query Language) is how an agent – or a report – asks Azquo for figures. You do not write SQL joins. You say which names go down the side, which go across the top, and what applies to every cell, and Azquo fills in the grid with correctly totalled figures.

The idea in one paragraph

Everything in Azquo is a name: a customer, a month, a product, a measure such as Sales. A name can contain other names, so a name is also a set – All Customers contains every customer, 2026 contains its months. Each figure is stored once, against the combination of names it belongs to (this customer, this month, Sales). Ask for a set and you get the total of everything inside it, at any level of the hierarchy, without having to say how to add it up.

The shape of a query

A query has three parts, each a grid of heading expressions laid out as they would be on a spreadsheet:

  • rowHeadings – what goes down the side;
  • columnHeadings – what goes across the top;
  • context – names that apply to every cell, such as a year or a scenario.
rowHeadings:    [["`All Customers` children"]]
columnHeadings: [["Sales"], ["Jan", "Feb", "Mar"]]
context:        [["2026"]]

This returns one row for each customer and three columns – January, February and March 2026 – each showing Sales. Sales is written once on the top line and applies to all three months below it. Every cell is the figure for its row name, its column names and the context together.

query_aql reads figures this way. aql_write takes the same layout plus a grid of values, and saves each value against the names of its cell.

Names

  • A name of more than one word goes in backticks: `All Customers`. A one-word name can go without; backticks are always safe.
  • Names are not case-sensitive: `all customers` finds All Customers.
  • A single name is treated as a set of one, so everything below works on one name or on thousands.

Laying out headings

Each heading grid is a list of rows, and each row is a list of cells, just as the heading area of a spreadsheet would look.

  • [["Amount", "Customer"]] is one row of headings with two cells: two columns.
  • [["Amount"], ["Customer"]] is two rows with one cell each: one column, with Customer stacked under Amount.
  • On the lines before the last, a heading applies until another heading or a . replaces it, so it need not be repeated. In the example above, Sales is written once and covers Jan, Feb and Mar.
  • The last line – the bottom row of column headings, or the right-hand column of row headings – is where figures come from, and it must be filled in every position that should show data. The lines above it add context.
  • A . on an earlier line stops a heading carrying on. On the last line it leaves that row or column empty, which keeps room for a formula or a note.

Moving around a hierarchy

These go after the name.

Expression Gives
X children the names one level below X
X level 2 the names two levels below (grandchildren); any number works. X children children does not go two levels – use level 2
X level all X and everything below it, in one list
X parents the sets X belongs to

Combining sets

An expression starts from a base set – the leftmost part, which you write out in full, e.g. `All Customers` children – and each operator then changes that set, working left to right. There is no precedence: the order you write is the order it runs.

Operator Keeps The right-hand side
A * B the members of A that are also within B A bare name means everything below it, so you need not spell it out: `All Customers` children * `UK` is the customers anywhere under UK, at whatever depth.
A / B the members of A that have figures connected to B Also everything below B. `All Customers` children / Widgets is the customers who have bought any widget. Use it to relate different kinds of thing – customers to products, suppliers to orders.
A + B A with B added Taken exactly as written: say + `Q4-26` children to add that quarter’s months, not just the quarter.
A - B A without B Taken exactly as written, as for +.

Use * to narrow a set by another set of the same kind (Catholic schools that are in London – both are schools); use / to connect different kinds. Operators work member by member: to cross customers with months, put customers in the rows and months in the columns – `customers` * `months` would look for customers that are also months.

Taking part of a set

Expression Gives
X from A to B the members from A to B, in order – e.g. `2026` children from `Mar-26` to `Jun-26`
X from A / X to B from A onwards / up to B
X count 10 only the first 10
X offset 10 skips the first 10
X sorted in ascending order across the whole list
X select "text" only names containing that text (any case)

Filtering: properties or figures?

Ask first whether you are filtering on a property of the name – a postcode, a start date – or on a figure stored against it.

  • Property:where. `All Customers` children where `postcode` = "SW1"
  • Figure, present at all:/, as above.
  • Figure, above or below a threshold:filterby, with the condition in quotes; one per expression. `All Orders` children filterby "`line count` > 1"

Showing properties and groups as columns

  • .postcode as a column heading shows each row name’s postcode property instead of a figure.
  • .`Sales Regions` – a dot before a set – shows, for each row, which member of that set it belongs to: each customer’s region, say.

Functions in a heading

  • count(), average(), max(), min(), percentile(set, p) and scale(set, factor) summarise a set. count(`All Orders` children * UK) counts UK orders.
  • exact(name) reads the figure held on a name itself, not the total of what is below it; and it is how you save a figure against a name that has members. A plain set heading shows a total and is not where a saved value lands.
  • default(name, fallback) shows the fallback where there is no figure.

Working sets with as

... as `Set name` fills a named set with the result of an expression – this month’s invoices for one customer, say – which reports and later queries can then use by name. It is filled again each time it runs. A new set made this way belongs to the person who ran it; asglobal makes it visible to everyone. query_aql only reads, so assignments run through aql_write, and Claude asks before running it.

Examples

Customers in the UK, with their sales for each month of 2026
  rowHeadings:    [["`All Customers` children * UK"]]
  columnHeadings: [["`2026` children"]]
  context:        [["Sales"]]

Customers who bought widgets, with their 2026 sales and postcode
  rowHeadings:    [["`All Customers` children / Widgets"]]
  columnHeadings: [["Sales", ".postcode"]]
  context:        [["2026"]]

The months March to June, with budget and actual side by side
  rowHeadings:    [["`2026` children from `Mar-26` to `Jun-26`"]]
  columnHeadings: [["Budget", "Actual"]]

Connected agents can read the full reference in the azquo_skills notes under AQL.

Safety

  • Changes are saved as they are made, and earlier values are kept with who changed them and when.
  • Deleted names can be restored.
  • A risky change can be rehearsed on a copy first (try_on_copy).
  • Deleting a database or a name that holds values is permanent. Claude asks before running any tool that changes or deletes data; tools that only read run straight away.

Help

Email info@azquo.com, or ask Azquo a question →

How Azquo fits with your other databases: Azquo beside your data platform →