gliana-ai-mcp 0.1.0

package/README.md

@@ -0,0 +1,62 @@
+# GlianaAI MCP server
+
+Pay-per-call generative AI for any MCP client (Claude Desktop, Cursor, …).
+**59 models** — image, video, music, speech — with **no signup and no API key**.
+Each `generate` is paid per call from **your own wallet** over MPP / x402.
+
+- Browse + price models for free (`list_models`, `get_price`, `get_schema`).
+- `generate` runs a model and settles the gateway's 402 from your wallet (USDC on
+  Base). Your private key is read from the client config and **never leaves your
+  machine** — non-custodial, same model as [ai.glianalabs.com](https://ai.glianalabs.com).
+
+## Tools
+
+| Tool | Paid? | Description |
+|------|-------|-------------|
+| `list_models` | free | Every model: id, category, provider, per-call price. |
+| `get_price` | free | Exact cost of one call (input affects it — video duration, TTS length). |
+| `get_schema` | free | A model's input fields (required, defaults). |
+| `generate` | **paid** | Run a model → media URL. Pays from your wallet. |
+
+## Install
+
+Add to your MCP client config.
+
+**Claude Desktop** (`claude_desktop_config.json`) / **Cursor** (`~/.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "gliana-ai": {
+      "command": "npx",
+      "args": ["-y", "gliana-ai-mcp"],
+      "env": {
+        "GLIANA_WALLET_KEY": "0xYOUR_PRIVATE_KEY"
+      }
+    }
+  }
+}
+```
+
+- `GLIANA_WALLET_KEY` — a `0x` private key for a wallet holding **USDC on Base**.
+  Required only for `generate`; omit it and the discovery tools still work.
+- `GLIANA_API_URL` — optional, defaults to `https://api.glianalabs.com`.
+
+Restart the client. Ask it to *"list GlianaAI models"* or *"generate an image of a
+red fox with nano-banana-2"*.
+
+## Funding
+
+Fund the wallet with a few dollars of USDC on Base. You pay only the per-call
+price (see `get_price`); there's no subscription and no balance held by us.
+
+> Use a dedicated low-balance wallet for agents. Never paste your main wallet's
+> key into any config.
+
+## Links
+
+- Website: https://ai.glianalabs.com
+- API docs: https://ai.glianalabs.com/docs
+- Discoverable on [mppscan](https://mppscan.com) and [x402scan](https://www.x402scan.com)
+
+MIT © Gliana Labs

package/dist/index.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/**
+ * GlianaAI MCP server — exposes pay-per-call generative AI (59 models: image,
+ * video, music, speech) to any MCP client (Claude Desktop, Cursor, …).
+ *
+ * Discovery tools (list_models / get_price / get_schema) are free. `generate`
+ * runs a model and settles the gateway's 402 challenge from YOUR wallet via mppx
+ * (USDC on Base). The key is read from GLIANA_WALLET_KEY in the client config and
+ * never leaves this process — non-custodial, same model as the web app.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { Mppx, evm } from 'mppx/client';
+import { privateKeyToAccount } from 'viem/accounts';
+import { z } from 'zod';
+const API = (process.env.GLIANA_API_URL ?? 'https://api.glianalabs.com').replace(/\/+$/, '');
+const RAW_KEY = process.env.GLIANA_WALLET_KEY?.trim();
+const WALLET_KEY = RAW_KEY
+    ? (RAW_KEY.startsWith('0x') ? RAW_KEY : `0x${RAW_KEY}`)
+    : undefined;
+const usd = (micro) => `$${(micro / 1_000_000).toFixed(6).replace(/0+$/, '').replace(/\.$/, '')}`;
+async function getJson(path) {
+    const r = await fetch(`${API}${path}`, { headers: { accept: 'application/json' } });
+    if (!r.ok)
+        throw new Error(`GET ${path} → HTTP ${r.status}`);
+    return (await r.json());
+}
+const ok = (s) => ({ content: [{ type: 'text', text: s }] });
+const fail = (s) => ({ content: [{ type: 'text', text: s }], isError: true });
+/** Find a renderable media URL in an inference result (gateway or raw provider shape). */
+function mediaUrl(output) {
+    const o = output;
+    if (!o || typeof o !== 'object')
+        return null;
+    for (const c of [o, o.result, o.output].filter((x) => !!x && typeof x === 'object')) {
+        for (const k of ['url', 'image', 'video', 'audio']) {
+            const v = c[k];
+            if (typeof v === 'string' && /^https?:\/\//.test(v))
+                return v;
+        }
+    }
+    return null;
+}
+const server = new McpServer({ name: 'gliana-ai', version: '0.1.0' });
+server.tool('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.', {}, async () => {
+    const { models } = await getJson('/v1/models');
+    const byCat = {};
+    for (const m of models)
+        (byCat[m.category] ??= []).push(m);
+    const out = Object.entries(byCat)
+        .map(([cat, ms]) => `## ${cat}\n` + ms.map((m) => `- ${m.id} (${m.provider}) — ${m.priceLabel}`).join('\n'))
+        .join('\n\n');
+    return ok(`${models.length} models on GlianaAI:\n\n${out}`);
+});
+server.tool('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.', {
+    model: z.string().describe('Model id from list_models, e.g. "nano-banana-2" or "veo-3.1-fast".'),
+    input: z.record(z.any()).optional().describe('Optional model input that affects price (e.g. { duration: 8 } or { text: "..." }).'),
+}, async ({ model, input }) => {
+    const qs = new URLSearchParams({ model });
+    if (input)
+        for (const [k, v] of Object.entries(input))
+            qs.set(k, String(v));
+    const p = await getJson(`/v1/price?${qs.toString()}`);
+    return ok(`${p.model}: ${usd(p.costMicroUsd)} (${p.units} ${p.unit}${p.units === 1 ? '' : 's'}).`);
+});
+server.tool('get_schema', 'Get a model’s input fields (names, types, which are required, defaults). Use before generate to know what to send. Free.', { model: z.string().describe('Model id from list_models.') }, async ({ model }) => {
+    const s = await getJson(`/v1/schema?model=${encodeURIComponent(model)}`);
+    return ok(`${s.model} (${s.category})\nrequired: ${s.required.join(', ') || '—'}\n\nfields:\n${JSON.stringify(s.props, null, 2)}`);
+});
+server.tool('generate', 'Run a model and return the result (media URL). PAID: settles the price from your wallet (USDC on Base) via GLIANA_WALLET_KEY. Call get_schema first for the input shape, get_price for the cost.', {
+    model: z.string().describe('Model id from list_models.'),
+    input: z.record(z.any()).describe('Model input, e.g. { prompt: "a red fox" } or { text: "hello" }. See get_schema.'),
+}, async ({ model, input }) => {
+    if (!WALLET_KEY) {
+        return fail('generate needs a funded wallet. Set GLIANA_WALLET_KEY (a 0x private key holding USDC on Base) in your MCP client config. ' +
+            'Discovery tools (list_models, get_price, get_schema) work without it.');
+    }
+    let account;
+    try {
+        account = privateKeyToAccount(WALLET_KEY);
+    }
+    catch {
+        return fail('GLIANA_WALLET_KEY is not a valid private key (expected 0x + 64 hex chars).');
+    }
+    const body = JSON.stringify({ model, ...input });
+    const run = () => {
+        // Fresh client per attempt so a stale 402 challenge is never reused.
+        const mppx = Mppx.create({ methods: [evm({ account })], polyfill: false });
+        return mppx.fetch(`${API}/v1/infer`, { method: 'POST', headers: { 'content-type': 'application/json' }, body });
+    };
+    let res = await run();
+    if (res.status === 402)
+        res = await run(); // one retry with a fresh challenge
+    if (res.status === 402)
+        return fail('Payment did not settle — check the wallet holds USDC on Base and try again.');
+    if (res.status === 400) {
+        const e = (await res.json().catch(() => ({})));
+        return fail(`Missing/invalid input (no charge): ${e.detail ?? 'see get_schema'}`);
+    }
+    if (!res.ok) {
+        const e = (await res.json().catch(() => ({})));
+        return fail(e.detail ?? e.error ?? `Request failed (HTTP ${res.status})`);
+    }
+    const result = (await res.json());
+    const url = mediaUrl(result.output);
+    const cost = usd(result.costMicroUsd);
+    if (url)
+        return ok(`${result.model} → ${url}\ncharged ${cost}`);
+    return ok(`${result.model} (charged ${cost}):\n${JSON.stringify(result.output, null, 2)}`);
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Stderr only — stdout is the MCP transport.
+    console.error(`gliana-ai MCP server ready (${API}). generate ${WALLET_KEY ? 'enabled' : 'disabled — set GLIANA_WALLET_KEY'}.`);
+}
+main().catch((err) => {
+    console.error('fatal:', err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "gliana-ai-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for GlianaAI — pay-per-call generative AI across 59 models (image, video, music, speech). No signup or API key; each generate is paid per call from your own wallet over MPP / x402.",
+  "type": "module",
+  "bin": {
+    "gliana-ai-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "mppx": "^0.6.31",
+    "viem": "^2.21.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.5.0",
+    "typescript": "^5.6.0"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "image-generation",
+    "video-generation",
+    "text-to-speech",
+    "music-generation",
+    "x402",
+    "mpp",
+    "pay-per-call",
+    "gliana"
+  ],
+  "author": "Gliana Labs",
+  "license": "MIT",
+  "homepage": "https://ai.glianalabs.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Gliana-Labs/gliana-mcp.git"
+  }
+}