MCP Autopilot

Trackily expose 181 tools MCP (Model Context Protocol) qui te permettent de piloter tout l'instance depuis Claude Desktop, Cursor, Zed, ChatGPT Desktop ou n'importe quel agent custom. Ce n'est pas une "intégration AI" superficielle — c'est l'API réelle du produit, exposée via un protocole standardisé que tous les clients LLM modernes savent parler.

Qu'est-ce que MCP ?

Model Context Protocol est un standard ouvert, publié par Anthropic, qui décrit comment un client LLM (Claude Desktop, Cursor…) découvre et appelle des "tools", "resources", et "prompts" exposés par un serveur tiers. C'est en quelque sorte le "USB-C des IAs" : un seul protocole, beaucoup d'apps des deux côtés.

Côté serveur, MCP est un wrapper JSON-RPC 2.0 sur HTTP (transport "streamable HTTP") ou stdio. Trackily implémente le transport HTTP, monté sur /mcp.

Côté client, le LLM se connecte au serveur, fait un handshake initialize, liste les tools/resources/prompts disponibles, et peut ensuite les appeler pendant une conversation. Le LLM n'a pas besoin de connaître l'API REST de Trackily — il lit les description + inputSchema de chaque tool et appelle ce qui semble pertinent.

Spec : https://modelcontextprotocol.io/specification.

Pourquoi 181 tools

Trackily, c'est une application dense : campaigns, offers, landings, flows, sources, automizer, native commerce, e-commerce externe (Shopify), email marketing, cloaking, AI landings, analytics, settings… Chaque domaine a typiquement 5-15 tools (list / get / create / update / delete + opérations spécialisées).

Le découpage est volontairement fin plutôt que générique : au lieu d'un seul tool trackily_call(method, params), on a list_campaigns, pause_campaign, duplicate_campaign, update_campaign_cost. Cela permet au LLM de proposer des actions précises sans avoir à composer manuellement des payloads compliqués, et permet le scoping fin (cf. Scopes).

Distribution des 181 tools par module :

Total : 181 tools. Tous référencés dans la tools reference.

Qui utilise ça ?

Claude Desktop

Le cas le plus naturel. Tu ajoutes Trackily dans ~/Library/Application Support/Claude/claude_desktop_config.json :

{
  "mcpServers": {
    "trackily": {
      "url": "https://trackily.online/mcp",
      "transport": "http",
      "headers": {
        "Authorization": "Bearer tly_ap_<your_token>"
      }
    }
  }
}

Tu relances Claude Desktop. Tu peux désormais demander : "Mes 5 meilleures campagnes ce mois ? Pause celles dont le ROI est négatif." Claude découvre get_stats, list_source_campaigns, suggest_optimizations, pause_campaign — il les enchaîne, te montre l'output, te demande validation avant les Tier-2 (les pauses).

Cursor

Va dans Settings → MCP Servers → Add. Même URL + bearer. Une fois branché, tu peux taper @trackily list my landings dans l'éditeur, ou demander à Cursor d'écrire du code qui interroge ton instance.

Zed

Configuration similaire dans ~/.config/zed/settings.json :

{
  "context_servers": {
    "trackily": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-fetch", "https://trackily.online/mcp"],
      "env": {
        "AUTHORIZATION": "Bearer tly_ap_<your_token>"
      }
    }
  }
}

ChatGPT Desktop

ChatGPT Desktop supporte MCP via le mode "Custom GPT Actions" ou le mode "Connectors". Branche l'URL /mcp + le bearer token, et tu peux interroger Trackily depuis une conversation ChatGPT.

Agents custom (Python, TypeScript, etc.)

N'importe quel agent qui parle JSON-RPC peut consommer Trackily. SDKs officiels :

• Python : pip install mcp (https://github.com/modelcontextprotocol/python-sdk)
• TypeScript : npm install @modelcontextprotocol/sdk (https://github.com/modelcontextprotocol/typescript-sdk)

Exemple Python minimal :

from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async with streamablehttp_client(
    "https://trackily.online/mcp",
    headers={"Authorization": "Bearer tly_ap_..."}
) as (read, write, _):
    async with ClientSession(read, write) as session:
        await session.initialize()
        tools = await session.list_tools()
        result = await session.call_tool(
            "list_campaigns",
            {"limit": 10, "is_active": True}
        )
        print(result)

Architecture interne

                ┌────────────────────────────────────────────────┐
                │                  CLAUDE / CURSOR                │
                │                (MCP client, JSON-RPC)           │
                └────────────────┬───────────────────────────────┘
                                 │
                                 ▼  HTTP POST /mcp
                ┌────────────────────────────────────────────────┐
                │              autopilot.js (core)                │
                │  ┌────────────────────┐  ┌─────────────────┐   │
                │  │   Auth middleware  │  │  Rate limiter   │   │
                │  │  (bearer → token)  │  │ (per-tok, /min) │   │
                │  └────────────────────┘  └─────────────────┘   │
                │  ┌────────────────────┐  ┌─────────────────┐   │
                │  │  Scope enforcement │  │   Audit logger  │   │
                │  └────────────────────┘  └─────────────────┘   │
                │  ┌────────────────────┐  ┌─────────────────┐   │
                │  │ JSON-RPC dispatch  │  │  Tier-2 helper  │   │
                │  └────────────────────┘  └─────────────────┘   │
                └────────────────┬───────────────────────────────┘
                                 │
            ┌────────────────────┼────────────────────────┐
            ▼                    ▼                        ▼
    ┌──────────────┐    ┌──────────────┐         ┌──────────────┐
    │ resources    │    │  tools/call  │         │ prompts/get  │
    │   /list /read│    │              │         │              │
    └──────┬───────┘    └──────┬───────┘         └──────┬───────┘
           │                   │                        │
           ▼                   ▼                        ▼
    autopilot-       autopilot-* 16 modules        autopilot-
    resources.js     (one per domain)              prompts.js
                                                   (slash commands)

Le core (autopilot.js) gère :

• Auth (resolution du bearer token, vérification d'expiration / révocation)
• Rate limiting (sliding window 60s par token, bucket default + bucket ai)
• Scope enforcement (chaque tool déclare ses scopes requis)
• Audit (chaque appel loggé dans autopilot_audit_log avec params + result status)
• Dispatch JSON-RPC (initialize, tools/list, tools/call, resources/list, resources/read, prompts/list, prompts/get)

Les 16 modules enregistrent leurs tools via autopilot.registerTool({ name, description, inputSchema, scopes, handler }). Chaque tool définit ses propres scopes et délègue au DB/business layer.

L'helper Tier-2 (autopilot-tier2.js) centralise la machinerie de confirmation à deux étapes pour les opérations destructives (cf. Tier System).

Voir aussi

• MCP — Concept — JSON-RPC, handshake, capabilities
• Tokens — création, révocation, rate limit, spend cap
• Scopes — les 42 scopes + 4 presets
• Tier System — Tier-1 vs Tier-2, confirm_token, idempotent replay
• Tools Reference — les 181 tools listés
• API — endpoints HTTP REST (alternative au MCP)