# Aito [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/AitoDotAI/aito-python-tools  
**GitHub Stars:** 5  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/aito

## Description
Predictions over your own data with $p and $why, no model training; says when Aito does not fit.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "aito": {
    "command": "uvx",
    "args": ["aitoai"],
    "env": {
      "AITO_URL": "",
      "AITO_API_KEY": "",
      "AITO_MCP_ALLOW_WRITES": ""
    }
  }
}
```

**Requires environment variables:** `AITO_URL`, `AITO_API_KEY`, `AITO_MCP_ALLOW_WRITES` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What the Aito MCP server does

The Aito MCP server gives MCP-compatible assistants access to an Aito instance through the `aito-mcp` command. It is intended for coding agents and assistants that need to inspect data, make predictions, explain results, or prepare Aito-backed features without embedding the Python SDK directly into an application.

Aito performs predictions over data already stored in an Aito instance and does not require users to train a model for these operations. Tool responses expose `$p` values for probabilities and flattened `$why` explanations. Tool descriptions also indicate situations where Aito is appropriate and cases where a language model, trained model, or search engine would be a better fit.

## How it works

Install the MCP extra for the Aito Python package, then start `aito-mcp` from an MCP client. The server uses the same instance-discovery behavior as `aito.Client()`: it can use configured environment variables or a local Aito profile. A local instance can be started with the package’s CLI, which listens on `http://127.0.0.1:9005` and stores its keys locally.

Communication uses standard MCP over stdio. For example, Claude Code can register the command with `claude mcp add aito -- aito-mcp`; other MCP clients can launch the same executable over stdio. The repository also contains a Claude Code plugin with a skill for adding predictive features. That workflow covers checking fit, deriving a schema, making an initial prediction, selecting a threshold with evaluation, and connecting the result to act, assist, or abstain behavior.

## Setup and configuration

Install Python 3.10 or newer and the MCP extra:

```console
pip install 'aitoai[mcp]'
```

Set `AITO_URL` and `AITO_API_KEY` when connecting to an Aito instance directly. If these are not set, the client can use the local server profile. The server is read-only unless `AITO_MCP_ALLOW_WRITES=1` is set, so enabling that variable changes the default access mode and should be deliberate.

The package also supports running Aito locally with `aito start`, checking it with `aito status`, viewing output with `aito logs`, and stopping it with `aito stop`. The local command stores data and keys when the instance is stopped.

## Tools and capabilities

The Aito MCP server exposes tools for:

- Predicting a value from table data.
- Recommending items.
- Relating records or values.
- Matching input against stored data.
- Searching and querying an instance.
- Evaluating predictive behavior.
- Inspecting schemas and uploading data.

These capabilities cover both read-oriented analysis and, when explicitly enabled, data or schema operations that require writes. The README does not specify individual argument schemas for each MCP tool, so integrations should inspect the server’s advertised tool definitions at runtime.

## Limitations and notes

Aito is not presented as a general replacement for language models, trained machine-learning models, or search engines. The tool descriptions explicitly include fit guidance, and the repository links to separate material about when Aito should not be used.

The MCP server is supplied through the Python package’s optional `mcp` dependency group. The base package, CLI extra, and MCP extra serve different purposes. The README does not list client-specific setup beyond Claude Code, although any MCP client that can run a stdio server can invoke `aito-mcp`.

The default read-only behavior is an important operational boundary. Do not assume that schema or upload operations can modify an instance unless the server was started with `AITO_MCP_ALLOW_WRITES=1`.

_Full upstream README: https://allmcps.com/mcp/aito/readme_