# GlianaAI [Health: Active]

**Category:** 🔎 Search & Data Extraction  
**Repository:** https://github.com/Gliana-Labs/gliana-mcp  
**GitHub Stars:** 0  
**npm Downloads (last month):** 3142  
**Views:** 2  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/glianaai

## Description
Pay-per-call AI: 59 generative models (image, video, music, speech). No signup, no API key.

## Tools
Capabilities this server exposes over MCP:

- **list_models** — List every GlianaAI model (id, category, provider, per-call price). Free — no payment. Use this to pick a model before get_price/generate.
- **get_price** — Quote the exact cost of one call for a model (optionally with input that affects price, e.g. video duration or TTS character count). Free.
- **get_schema** — Get a model’s input fields (names, types, which are required, defaults). Use before generate to know what to send. Free.
- **generate** — Run a model and return the result — a media URL for image/video/audio/music models, assistant text for text (LLM) models. Text models take OpenAI-style input: { messages: [{ role, content }, …], max_tokens? }. PAID: settles the price from your wallet over the configured rail (base/tempo/solana). Call get_schema first for the input shape, get_price for the cost. File inputs (image/video/audio, e.g. image-to-video or video-to-video `video_uri`) take a public URL — upload a local file with POST /v1/media (≤40MB) to get one. Array file fields (e.g. `images`, `reference_images` for multi-reference models) take an ARRAY of such URLs.
- **list_tools** — List every GlianaAI utility tool (name, HTTP method, per-call price, an example input, and usage guidance), read live from the gateway so it is always current. Free — no payment. Call this before `tool` to pick one and learn its input shape. Tools reported at priceMicroUsd 0 are free to call and need no wallet.
- **tool** — Run a UTILITY tool (not an AI model) — scraping, screenshots, social cards, market data, chain RPC, OCR, address parsing, structured extraction, Indonesian reference data. Call list_tools FIRST for the live list with prices and input shapes: it is read from the gateway, so it is never out of date, and this description deliberately does not enumerate them. Most tools are PAID and settle a flat price from your wallet (base/tempo/solana); the ones list_tools reports at priceMicroUsd 0 are free and need no wallet at all.
- **recipe** — Run a paid multi-model RECIPE pipeline (chains models in one call). PAID: settles the SUM of the steps from your wallet (base/tempo/solana). Recipes: `image-to-video` {prompt,motionPrompt?} text→image→animated video (3-8x cheaper than a native text-to-video model), `image-to-video-hd` (crisper still), `image-to-video-audio` (video with sound), `brainrot-video` {motionPrompt?,reference_image?} random Italian-brainrot creature → video with audio (no prompt). Override steps with { imageModel, videoModel }. See https://ai.glianalabs.com/docs#recipes.

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

```json
"mcpServers": {
  "glianaai": {
    "command": "npx",
    "args": ["-y","gliana-ai-mcp"]
  }
}
```

## Documentation

## What GlianaAI does

GlianaAI exposes a pay-per-call catalog of generative AI models and gateway utility tools through MCP. The model catalog covers image, video, video editing, music, speech, and LLM chat use cases. Model calls return a media URL for supported media models or assistant text for chat models.

Its utility layer is discovered dynamically rather than through a fixed list. Depending on what the gateway reports, utilities can cover scraping, screenshots, social cards, OCR, structured extraction, market data, chain RPC, address parsing, and Indonesian reference data. The server also supports recipes that combine multiple model calls into one operation, including text-to-image-to-video pipelines and audio-enabled video workflows.

## How it works

The server runs as an MCP process, normally launched with `npx gliana-ai-mcp`. Agents can first call `list_models`, `get_price`, and `get_schema` to select a model, calculate the call cost, and determine its required inputs. `list_tools` provides the live utility catalog, including each utility’s method, price, example input, and usage guidance.

`generate` executes a selected model, while `tool` executes a gateway utility and `recipe` runs a paid multi-model pipeline. Text models accept OpenAI-style message arrays. File-based model inputs must use public URLs. Local image, video, or audio files can be uploaded without payment through `POST https://api.glianalabs.com/v1/media`; uploads are limited to 40 MB.

Paid requests can use a prepaid `gk_` key or a wallet-based payment flow. Wallet settlement supports Base, Tempo, and Solana, with USDC held on the selected rail. Wallet signatures are created locally. Discovery tools and utilities reported with a zero price do not require payment credentials.

## Setup and configuration

Install the package through an MCP client using the `gliana-ai-mcp` npm command. Claude Code provides a plugin installation command, while Cursor, Codex, Claude Desktop, and other MCP clients can launch the process with an `npx` command and environment configuration.

A prepaid key is created through the GlianaAI dashboard and is supplied as `GLIANA_API_KEY`. This route uses loaded account balance and avoids placing a wallet private key in the client configuration. The alternative wallet route uses an EVM key for Base or Tempo, or a Solana secret key for Solana. Key files are supported and are preferable to inline secrets for client configurations that may sync or be shared.

`GLIANA_RAIL` selects `base`, `tempo`, or `solana`; Base is the default unless only a Solana key is configured. `GLIANA_API_URL` can override the default gateway URL. Optional per-call and per-day spending limits can be set with `GLIANA_MAX_PER_CALL_USD` and `GLIANA_MAX_PER_DAY_USD`. The daily local total persists in `~/.gliana-ai-mcp/spend.json`.

## Tools and capabilities

- `list_models`: Enumerates models with identifiers, categories, providers, and prices.
- `get_price`: Quotes the cost of a model call, including input-dependent pricing such as video duration or text-to-speech length.
- `get_schema`: Shows model fields, types, required values, and defaults.
- `generate`: Runs a model and returns media or assistant text.
- `list_tools`: Reads the gateway’s current utility catalog and pricing.
- `tool`: Runs a selected utility endpoint.
- `recipe`: Runs supported multi-model workflows such as image-to-video and audio-enabled video generation.
- `get_balance`: Reports the remaining balance for a configured prepaid key.

Recipes include `image-to-video`, `image-to-video-hd`, `image-to-video-audio`, and `brainrot-video`. Recipe inputs can include prompts, motion prompts, reference images, and model overrides depending on the recipe.

## Limitations and notes

Paid model, utility, and recipe calls spend money. Agents should inspect prices before execution and use spending caps when wallet or prepaid-key automation could run repeatedly. A wallet-based setup should use a dedicated, limited-funds wallet because its private key resides on the machine running the MCP client.

File inputs need publicly reachable URLs and are limited to image, video, or audio uploads of 40 MB or less through the media endpoint. Utility availability and pricing are read from the live gateway, so the available set can change. The `watch` command polls one endpoint on a schedule and pays from a wallet rather than a prepaid key.

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