MCP Server & Agent Skills

The AIOZ AI MCP server lets an AI agent run the AIOZ AI Platform for you. It exposes the platform as Model Context Protocol (opens in a new tab) tools, so a client like Claude Code can discover models, submit inference tasks, upload files, and check your balance without you writing any HTTP or SDK code. The skills sit on top of the tools: they teach the agent the correct inference and file-upload lifecycle so runs succeed instead of failing on a malformed request or an empty balance.

Install steps depend on your client, so the canonical, always-current install guide lives in the public developer repo:

https://github.com/AIOZNetwork/aioz-ai-developer (opens in a new tab)

This page explains what you're installing and what works where; follow the repo for the exact per-client config.

What you get

The MCP server: A server you run with npx. It surfaces the platform as MCP tools (models, tasks, storage, balance, and more) that any MCP-capable client can call. Every authenticated tool call carries your API key, so the agent acts as you.
Two agent skills: Reusable instructions that make the agent use the tools correctly:
- aioz-ai-run-inference finds a model, reads its input/output schema and cost, checks your balance, submits a task, polls it to completion, and reports the result. It handles the asynchronous task lifecycle and never fabricates a result.
- aioz-ai-upload-file uploads a local file to storage and gives you a download_url you can pass as a model input. The inference skill calls it whenever a model takes a file.

The server, the skills, and the docs move together under a single release tag, so a given version always matches the skill instructions and the tool reference.

Install

Follow the developer repo (opens in a new tab) for the current, per-client steps. There are two pieces:

The server: Register the MCP server in your client's configuration as an npx command. A typical MCP client config looks like this:
```
{
  "mcpServers": {
    "aioz-ai": {
      "command": "npx",
      "args": ["-y", "@aiozai/mcp-server"]
    }
  }
}
```
The repo's install guide covers each client's exact config file and where your API key goes. You'll need an API key first; see Managing API Keys and Authentication.
The skills: Install them from the same repo. Pin them to the release tag that matches your server version so the instructions and the tool surface stay in lockstep:
```
npx skills add AIOZNetwork/aioz-ai-developer/skills/aioz-ai-run-inference
npx skills add AIOZNetwork/aioz-ai-developer/skills/aioz-ai-upload-file
```
Install both together: the inference skill calls the upload skill for file inputs.

Using your API key

The MCP server calls the AIOZ AI API as you, so it needs your API key exactly as a direct API integration would. You supply the key once in your client's MCP configuration (the repo's install guide shows the exact field per client); the server then attaches it to every authenticated tool call. Treat it like any other secret: don't commit it, and rotate it if it leaks. See Managing API Keys.

First inference

Once the server and skills are installed, ask your agent in plain language to run a model, for example "run image background removal on this file". The aioz-ai-run-inference skill drives the rest: it picks a model, reads its schema and cost, checks your balance, submits the task, waits for it, and reports the output. If the model takes a file, the aioz-ai-upload-file skill uploads it first and passes the resulting URL as the input.

Everything the agent does through MCP maps to the same primitives you can use directly. For the underlying concepts, see:

Working with Models: discovery, schemas, cost, and serving status.
Working with Tasks: the asynchronous create, poll, then read lifecycle.
Working with Storage: the presigned-URL upload flow behind the upload skill.
How Billing Works: how each inference draws from your balance.

When to use MCP vs the SDK or HTTP API

MCP is for driving the platform from an AI agent in natural language, with the skills handling the lifecycle. Best when the agent is doing the work.
SDKs are for building your own application in Python, Node, or Go with typed calls.
The HTTP API is for any other language or when you need full control over the transport.

All three hit the same compute network and the same models; pick the layer that fits how you're building.