Invariant

Die agentische API-Bereitstellungsschicht. Ihr KI-Agent erhält Wetterdaten, Aktienkurse, Gesundheitsdaten, Karten und führende LLMs über einen einzigen Endpunkt. invariant erstellt die Konten, verwaltet die Schlüssel, setzt Kontingente durch und springt ein, wenn etwas ausfällt. Sie müssen nie ein Entwicklerportal berühren.

Ein Schlüssel rein. Jede API raus.

Warum existiert invariant?

Ein nützlicher KI-Agent muss zehn verschiedene Dienste aufrufen. Ein LLM, eine Wetter-API, einen Aktienticker, einen Geocoder, eine Gesundheitsdatenbank, eine Suche für Wohltätigkeitsorganisationen. Das heute aufzubauen bedeutet:

• Zehn Entwicklerportale, zehn Anmeldeformulare, zehn E-Mail-Bestätigungen

• Zehn API-Schlüssel, die rotiert und gesichert werden müssen

• Zehn verschiedene Authentifizierungsschemata, Ratenbegrenzungen und Fehlerformate

• Zehn Möglichkeiten, wie ein einzelner Aufruf fehlschlagen kann, und kein Fallback, wenn einer ausfällt

invariant fasst all das in einer verwalteten Schicht zusammen. Sie verbinden sich einmal über MCP oder REST, und die Bereitstellung, das Routing, die Kontingentabrechnung und das Failover geschehen oberhalb Ihres Agenten.

Related MCP server: Frostbyte MCP

Anbieterkatalog

In der gehosteten Instanz übernimmt invariant jede Zeile mit "Kostenlose Anm." für Sie. Sie sehen diese Portale nie. Selbst gehostete Instanzen können ihre eigenen Schlüssel über Umgebungsvariablen einbringen.

Funktionsweise

         ┌─────────────────────┐
         │    Your AI Agent    │
         │  (Claude, Cursor,   │
         │   Codex, custom)    │
         └──────────┬──────────┘
                    │ MCP (JSON-RPC) or REST
                    │ single key: x-pl-key
                    ▼
         ┌─────────────────────────────────┐
         │            invariant              │
         │  ┌───────────────────────────┐  │
         │  │  auth + quota             │  │
         │  │  (Supabase + Upstash)     │  │
         │  ├───────────────────────────┤  │
         │  │  reasoning layer          │  │
         │  │  (recommend / compare)    │  │
         │  ├───────────────────────────┤  │
         │  │  provider router + fall-  │  │
         │  │  back + usage logging     │  │
         │  └───────────────────────────┘  │
         └──────────┬──────────────────────┘
                    │ managed upstream credentials
                    ▼
  OpenFDA . Mental Health . CoinGecko . Finnhub . Every.org
  OpenWeatherMap . Anthropic . Gemini . HuggingFace . Geoapify

Zugriffsmodi

invariant stellt dieselbe Engine über zwei Schnittstellen bereit.

1. MCP (empfohlen für KI-Clients). JSON-RPC über HTTP unter POST /api/mcp. Funktioniert mit Claude Desktop, Cursor, Claude Code, Windsurf, Cline, Continue.dev, Codex CLI, Goose und der OpenAI Responses API.

2. REST (für eigenen Code). Einfache HTTP-Endpunkte, falls Sie Ihre eigene Integration bauen:

Jeder Endpunkt erfordert einen x-pl-key: pl_... Header.

Erste Schritte

1. Holen Sie sich Ihren invariant-Schlüssel

Registrieren Sie sich bei der gehosteten Instanz. Sie erhalten einen pl_... Schlüssel. Das ist die einzige Anmeldeinformation, die Sie jemals sehen. Dahinter hält invariant bereits jedes Upstream-Konto für Sie bereit.

2. Verbinden Sie Ihren KI-Client

Alle Clients verbinden sich mit demselben Remote-Endpunkt. Kein Klonen, kein Bauen, kein Node.js erforderlich.

URL:    https://pclabs.dev/api/mcp
Header: x-pl-key: pl_your_key_here

Claude Code (CLI)

claude mcp add invariant --transport http https://pclabs.dev/api/mcp --header "x-pl-key: pl_your_key_here"

Claude Desktop

Bearbeiten Sie ~/Library/Application Support/Claude/claude_desktop_config.json (Mac) oder %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "invariant": {
      "type": "http",
      "url": "https://pclabs.dev/api/mcp",
      "headers": {
        "x-pl-key": "pl_your_key_here"
      }
    }
  }
}

Starten Sie Claude Desktop nach dem Speichern neu.

claude.ai (Web)

Einstellungen → Integrationen → Benutzerdefinierte Integration hinzufügen. Fügen Sie die URL ein und setzen Sie den x-pl-key Header im Formular. Keine Dateibearbeitung.

Cursor

Bearbeiten Sie ~/.cursor/mcp.json (global) oder .cursor/mcp.json (pro Projekt):

{
  "mcpServers": {
    "invariant": {
      "url": "https://pclabs.dev/api/mcp",
      "headers": {
        "x-pl-key": "pl_your_key_here"
      }
    }
  }
}

Oder über die Benutzeroberfläche: Einstellungen → Tools & Integrationen → MCP → Server hinzufügen.

Windsurf

Bearbeiten Sie ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "invariant": {
      "url": "https://pclabs.dev/api/mcp",
      "headers": {
        "x-pl-key": "pl_your_key_here"
      }
    }
  }
}

Oder über die Benutzeroberfläche: Cascade-Panel → MCP-Server → Konfigurieren.

Cline (VS Code Erweiterung)

1. Öffnen Sie die Cline-Seitenleiste

2. Klicken Sie auf den Tab "MCP-Server" (Stecker-Symbol)

3. Server hinzufügen → HTTP

4. Fügen Sie https://pclabs.dev/api/mcp als URL ein

5. Fügen Sie den Header x-pl-key: pl_ihr_schluessel_hier hinzu

Continue.dev

Bearbeiten Sie ~/.continue/config.json:

{
  "mcpServers": [
    {
      "name": "invariant",
      "transport": {
        "type": "http",
        "url": "https://pclabs.dev/api/mcp",
        "headers": {
          "x-pl-key": "pl_your_key_here"
        }
      }
    }
  ]
}

OpenAI Codex CLI

Bearbeiten Sie ~/.codex/config.toml:

[mcp_servers.invariant]
type = "http"
url = "https://pclabs.dev/api/mcp"

[mcp_servers.invariant.headers]
x-pl-key = "pl_your_key_here"

OpenAI Responses API

Übergeben Sie den MCP-Server direkt als Tool:

response = client.responses.create(
    model="codex-mini-latest",
    tools=[{
        "type": "mcp",
        "server_url": "https://pclabs.dev/api/mcp",
        "headers": { "x-pl-key": "pl_your_key_here" }
    }],
    input="What crypto prices are available?"
)

Goose (Block)

Bearbeiten Sie ~/.config/goose/config.yaml:

extensions:
  invariant:
    type: mcp
    enabled: true
    transport: http
    url: https://pclabs.dev/api/mcp
    headers:
      x-pl-key: pl_your_key_here

MCP-Tools

Der MCP-Endpunkt stellt vier Tools bereit.

recommend

Beschreiben Sie, was Sie benötigen. invariant gibt bewertete Anbieter mit Punktzahlen, Begründung, Preisgestaltung und Verfügbarkeit zurück. Dies ist der agentische Einstiegspunkt. Agenten sollten hier beginnen, nicht mit query.

{
  "need": "real-time crypto prices with no signup",
  "priorities": ["no-auth", "cost"],
  "budget": "free"
}

compare

Direkter Vergleich von zwei oder mehr Anbietern hinsichtlich Preisgestaltung, Ratenbegrenzungen, Stärken und Schwächen.

{ "provider_ids": ["claude", "gemini"] }

list_providers

Durchsuchen Sie den Katalog, optional gefiltert nach Kategorie: physical_health, mental_health, financial, social_impact, environment, ai, maps.

query

Führen Sie eine spezifische Aktion bei einem bestimmten Anbieter aus. Das Low-Level-Primitiv, das recommend letztendlich aufruft.

{
  "provider_id": "coingecko",
  "action": "price",
  "params": { "ids": "bitcoin", "vs_currencies": "usd" }
}

Selbst-Hosting

Sie können Ihre eigene invariant-Instanz betreiben, wenn Sie Ihre eigenen Upstream-Anmeldeinformationen einbringen oder auf Ihrer eigenen Infrastruktur hosten möchten.

Voraussetzungen

• Node.js 18+

• Ein Supabase-Projekt für Konten und Nutzungsprotokollierung. Siehe migration.sql für das Schema.

• Eine Upstash Redis-Instanz für die Ratenbegrenzung pro Minute

Bereitstellung auf Railway

invariant läuft als einzelner Node-HTTP-Server, der in dev-server.ts definiert ist und die Routen-Handler in api/ sowie die Admin-, Anmelde- und Wartelisten-Routen einbindet. Railway erkennt das start-Skript automatisch, daher ist keine railway.toml oder Procfile erforderlich.

npm install
npm run build
npm start     # runs dist/dev-server.js on $PORT

Verweisen Sie Railway auf dieses Repository und setzen Sie die unten aufgeführten Umgebungsvariablen im Railway-Dashboard.

Umgebungsvariablen

Plattform (erforderlich):

Upstream-Anbieter (optional). Lassen Sie eine Variable weg, um diesen Anbieter zu deaktivieren:

Anbieter ohne konfigurierten Schlüssel zeigen Status: Not configured in list_providers an und geben bei Abfrage einen 503-Fehler zurück. OpenFDA und Mental Health Resources funktionieren ganz ohne Schlüssel.

Bereitstellung von Schlüsseln

Schlüssel leben in Supabase, nicht in einer Umgebungsvariable. Wenden Sie migration.sql auf Ihr Projekt an, um die Tabellen accounts und usage zu erstellen, und erstellen Sie dann Konten über die Admin-Endpunkte (geschützt durch ADMIN_PASSWORD) oder durch direktes Einfügen von Zeilen. Jede Kontozeile enthält einen pl_... Schlüssel, einen Tarif, ein monatliches Kontingent und eine Rate pro Minute.

Lokale Entwicklung

cp .env.example .env          # fill in your values
npm install
npx tsx dev-server.ts         # HTTP server with hot-restart via tsx

Der Server lauscht auf $PORT (Standard: 3000). Rufen Sie http://localhost:3000/api/providers mit Ihrem x-pl-key Header auf, um die Funktion zu überprüfen.

Um stattdessen das stdio-MCP-Fallback (siehe unten) auszuführen, verwenden Sie npm run dev.

Fallback: lokales stdio-MCP

Für MCP-Clients, die kein HTTP sprechen, liefert das Repository auch einen schlanken stdio-Proxy in src/, der an ein Remote-invariant-Backend weiterleitet:

npm install
npm run build

{
  "mcpServers": {
    "invariant": {
      "command": "node",
      "args": ["/absolute/path/to/invariant/dist/index.js"],
      "env": {
        "PL_API_KEY": "pl_your_key_here",
        "PL_BACKEND_URL": "https://pclabs.dev/api/mcp"
      }
    }
  }
}

MCP-Client-Umgebungsvariablen für den stdio-Pfad:

Hinzufügen eines Anbieters

1. Erstellen Sie lib/providers/my-provider.ts, das das Provider-Interface aus lib/providers/types.ts implementiert

2. Registrieren Sie es in lib/providers/registry.ts

3. Fügen Sie alle erforderlichen Umgebungsvariablen zu .env.example hinzu

4. Fügen Sie Metadaten zu lib/reasoning/ hinzu, damit das recommend-Tool sie anzeigen kann

Skripte

npm run dev    # stdio MCP server via tsx, no build
npm run build  # compile TypeScript → dist/
npm start      # run compiled standalone server (dist/dev-server.js)
npm test       # run test.ts against local backend

Aufgebaut auf MCP, Hono, Supabase und Upstash Redis.