> ## Documentation Index
> Fetch the complete documentation index at: https://docs.uatu.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Build with AI agents

> Give coding agents accurate uatu context through Markdown, MCP, or OpenAPI.

uatu publishes its documentation in formats that coding agents can read directly.
Use a Markdown page for a focused task, `llms.txt` for documentation discovery, MCP
for ongoing search, or the OpenAPI document to generate a typed client.

The documentation is public. Your application still needs an [API key](/console) to
request a quote from `https://api.uatu.dev`.

<Warning>
  Do not paste an API key into a prompt or send it to the documentation MCP server.
  Keep the key in server-side secret storage and load it at runtime.
</Warning>

## Choose a context source

| Need | Source |
| - | - |
| Find the relevant documentation | [`llms.txt`](https://docs.uatu.dev/llms.txt) |
| Provide the complete documentation in one file | [`llms-full.txt`](https://docs.uatu.dev/llms-full.txt) |
| Explain the quote-to-transaction flow | [`integration.md`](https://docs.uatu.dev/guides/integration.md) |
| Generate types or a client | [`openapi.json`](https://docs.uatu.dev/api-reference/openapi.json) |
| Search the docs throughout a task | [uatu docs MCP](https://docs.uatu.dev/mcp) |

Start with `llms.txt` for most tasks. It is an index that lets the agent find and
read only the pages it needs. Use `llms-full.txt` when the agent cannot fetch linked
pages or when you need a single offline snapshot.

You can also append `.md` to an individual documentation URL to retrieve that page
as plain Markdown:

```text theme={null}
https://docs.uatu.dev/guides/integration.md
https://docs.uatu.dev/concepts/quotes.md
https://docs.uatu.dev/concepts/quotes/create-your-first-quote.md
```

A concise starting instruction is often enough:

```text theme={null}
Read https://docs.uatu.dev/llms.txt. Find the pages relevant to implementing a uatu
swap with viem, then follow those pages as the source of truth.
```

## Connect the documentation MCP server

Connect MCP when an agent needs to search and revisit the docs throughout a longer
task. The server is public and read-only with respect to the uatu API:

```text theme={null}
https://docs.uatu.dev/mcp
```

<Tabs>
  <Tab title="Claude Code">
    ```sh theme={null}
    claude mcp add --transport http uatu-docs https://docs.uatu.dev/mcp
    ```
  </Tab>

  <Tab title="Cursor">
    Add this server to `~/.cursor/mcp.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "uatu-docs": {
          "url": "https://docs.uatu.dev/mcp"
        }
      }
    }
    ```
  </Tab>

  <Tab title="VS Code">
    Add this server to `.vscode/mcp.json`:

    ```json theme={null}
    {
      "servers": {
        "uatu-docs": {
          "type": "http",
          "url": "https://docs.uatu.dev/mcp"
        }
      }
    }
    ```
  </Tab>

  <Tab title="Claude Desktop">
    Add this server to `claude_desktop_config.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "uatu-docs": {
          "command": "npx",
          "args": ["-y", "mcp-remote", "https://docs.uatu.dev/mcp"]
        }
      }
    }
    ```
  </Tab>
</Tabs>

Once connected, the agent can search the documentation, read pages, and report
documentation feedback. The server cannot create quotes, sign transactions, or
access your API key.

## Generate a typed client

Use the OpenAPI document when the task is primarily about request and response
types:

```text theme={null}
https://docs.uatu.dev/api-reference/openapi.json
```

It defines the API endpoints and schemas consumed by tools such as
`openapi-typescript` and `openapi-generator`. Generated types help prevent agents
from borrowing incompatible field names from other swap APIs.

## Use a constrained implementation prompt

Tell the agent what to build and which safety boundaries it must preserve. Adapt
this template to your project:

```text theme={null}
Read https://docs.uatu.dev/llms.txt and use the linked uatu documentation as the
source of truth.

Implement a server-side swap flow using the uatu API at https://api.uatu.dev and
the conventions already used in this repository.

Requirements:
- use POST /quotes to get the best executable quote
- load UATU_API_KEY from the server environment and send it as a bearer token
- send `amount` as a decimal string in the input token's display units
- read the quote from the response's `data` field
- show `amountOutFloat` to the user and require confirmation before broadcasting
- reject an expired quote by checking `deadline` against the current Unix time
- submit every transaction in `steps` in order and wait for each receipt
- include `value` when a step provides it
- request a new quote after an expired quote or market-movement revert
- never invent endpoints, request fields, or response fields

Use viem. Keep signing in the wallet client; uatu only returns transaction data.
Run the relevant tests and report the files changed.
```

<Note>
  Documentation access and transaction authority are separate. An agent may read
  these docs freely, but your application should still require explicit user
  confirmation before a wallet signs or broadcasts a quote step.
</Note>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.