RubiConnect MCP-Integrationsleitfaden

2.1 Integrierter Claude-Connector (Desktop-App & Claude.ai Web) — Empfohlen

Gleich ob Sie die Claude Desktop-Anwendung unter macOS/Windows oder Claude.ai im Webbrowser nutzen: Anthropic bietet eine integrierte Point-and-Click-Connector-Schnittstelle basierend auf OAuth 2.0 mit PKCE. Dies ist der einfachste Weg, RubiConnect ohne Terminal-Konfiguration mit Claude zu verbinden.

1. Navigieren Sie in Claude Desktop oder Claude.ai zu Settings > Connectors (oder wählen Sie Add Custom Connector).
2. Geben Sie die Server-URL ein:

   https://console.rubiconnect.com/api/mcp

1. Im OAuth-Verbindungsfenster:
   • Client ID: Fügen Sie Ihren RubiConnect API-Schlüssel ein (z. B. rc_live_...).
   • Client Secret: Leer lassen (RubiConnect nutzt RFC 7636 PKCE, welches kein statisches Secret erfordert).
2. Claude öffnet Ihren Browser mit der RubiConnect-Autorisierungs-Bridge (/de/authorize), validiert Ihren API-Schlüssel und schließt den Handshake automatisch ab.
3. Alle 16 Messaging-, Kampagnen-, Vorlagen- und Analysetools stehen sofort in Ihren Claude-Chat-Sitzungen zur Verfügung.

2.2 OpenAI Custom GPTs & Enterprise-Agenten-Plattformen

Um RubiConnect an ChatGPT Custom GPTs oder Enterprise-Orchestrierungsplattformen (wie Flowise, LangChain oder Zapier Central) anzubinden:

1. Im GPT-Editor navigieren Sie zu Actions > Create new action.
2. Wählen Sie unter Authentication die Option OAuth:
   • Client ID: Geben Sie Ihren RubiConnect API-Schlüssel ein (rc_live_...).
   • Client Secret: Beliebiger Platzhalter (oder leer lassen, falls unterstützt).
   • Authorization URL: https://console.rubiconnect.com/de/authorize
   • Token URL: https://console.rubiconnect.com/api/oauth/token
   • Scope: mcp (oder leer lassen).
   • Token Exchange Method: POST request (Basic or Body)
3. Importieren Sie die MCP-Tool-Definitionen von https://console.rubiconnect.com/api/mcp oder kopieren Sie das OpenAPI-Schema.
4. Speichern und testen Sie die Aktion; ChatGPT authentifiziert sich nahtlos über die OAuth-Bridge von RubiConnect.

2.3 Claude Desktop JSON-Datei (claude_desktop_config.json) — Alternative Stdio-Bridge

Falls Sie als Entwickler Claude Desktop lieber manuell über die Datei claude_desktop_config.json auf Ihrer Festplatte konfigurieren möchten (anstatt die in Abschnitt 2.1 beschriebene Benutzeroberfläche zu verwenden), erwartet Claude Desktop einen lokalen stdio-Subprozess. Da der RubiConnect MCP-Server als entfernter HTTP-SSE-Dienst gehostet wird, erfordert die manuelle Konfiguration ein Bridge-Tool (wie mcp-remote), um stdio an den entfernten SSE-Endpunkt weiterzuleiten.

Empfohlene Konfiguration (mcp-remote)

Fügen Sie die folgende Konfiguration zu Ihrer claude_desktop_config.json hinzu:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "rubiconnect": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://console.rubiconnect.com/api/mcp",
        "--header",
        "Authorization:Bearer ${RUBI_API_KEY}"
      ],
      "env": {
        "RUBI_API_KEY": "rc_live_ihr_echter_schluessel_hier"
      }
    }
  }
}

Syntax-Hinweis: Der Parameter --header muss exakt als "Authorization:Bearer ${RUBI_API_KEY}" ohne Leerzeichen nach dem Doppelpunkt formatiert sein.

macOS GUI PATH-Auflösung: Die Desktop-GUI-Anwendung von Claude erbt nicht automatisch den PATH Ihrer Terminal-Shell (.zshrc oder .bashrc). Falls Claude meldet command not found: npx, ersetzen Sie "command": "npx" durch den absoluten Pfad zu Ihrer Node/npx-Binärdatei:

* Apple Silicon (M1/M2/M3/M4): "/opt/homebrew/bin/npx"

* Intel Mac: "/usr/local/bin/npx"

* Führen Sie im Terminal which npx aus, um den genauen Pfad zu ermitteln.

Alternative: Gebündeltes Node.js-Bridge-Skript

Falls Sie mcp-remote nicht bei jedem Start über npx ausführen möchten, stellt RubiConnect ein eigenständiges Bridge-Skript im Plattform-Repository unter scripts/claude-mcp-bridge.mjs bereit:

{
  "mcpServers": {
    "rubiconnect": {
      "command": "node",
      "args": ["/absoluter/pfad/zu/RubiConnect platform/scripts/claude-mcp-bridge.mjs"],
      "env": {
        "RUBI_API_KEY": "rc_live_ihr_echter_schluessel_hier"
      }
    }
  }
}

2.4 Cursor IDE

Cursor unterstützt entfernte Server-Sent Events (SSE) MCP-Server nativ ohne lokale Bridge:

1. Öffnen Sie Cursor und drücken Sie Cmd + , (bzw. Ctrl + ,), um die Einstellungen zu öffnen.
2. Navigieren Sie zu Features > MCP.
3. Klicken Sie auf + Add New MCP Server.
4. Tragen Sie die Verbindungsdaten ein:
   • Name: rubiconnect
   • Type: SSE
   • URL: https://console.rubiconnect.com/api/mcp
   • Headers: {"Authorization": "Bearer rc_live_ihr_echter_schluessel_hier"} (oder {"X-Rubi-Key": "rc_live_ihr_echter_schluessel_hier"})
5. Cursor verbindet sich umgehend und zeigt einen grünen Indikator neben rubiconnect mit allen 16 registrierten Tools an.

2.5 Verbindung über das Python-SDK

Verwendung der offiziellen Python-Bibliothek mcp:

import asyncio
from mcp import ClientSession
from mcp.client.sse import sse_client

async def main():
    headers = {"Authorization": "Bearer rc_live_ihr_echter_schluessel_hier"}
    async with sse_client("https://console.rubiconnect.com/api/mcp", headers=headers) as (read_stream, write_stream):
        async with ClientSession(read_stream, write_stream) as session:
            await session.initialize()
            
            # Verfügbare Tools auflisten
            tools = await session.list_tools()
            print("Verfügbare Tools:", len(tools.tools))
            
            # Aktive Messaging-Agents abrufen
            result = await session.call_tool("list_agents", {})
            print("Agents:", result.content[0].text)

asyncio.run(main())

2.6 Verbindung über das Node.js-SDK

Verwendung des offiziellen JavaScript-Pakets @modelcontextprotocol/sdk:

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";

async function main() {
  const transport = new SSEClientTransport(
    new URL("https://console.rubiconnect.com/api/mcp"),
    {
      headers: {
        "Authorization": "Bearer rc_live_ihr_echter_schluessel_hier"
      }
    }
  );

  const client = new Client({
    name: "rubiconnect-mcp-client",
    version: "1.0.0"
  }, {
    capabilities: {}
  });

  await client.connect(transport);

  // Tools auflisten
  const { tools } = await client.listTools();
  console.log(`${tools.length} Tools erkannt`);

  // Liste der Messaging-Agents abrufen
  const agentsResponse = await client.callTool({
    name: "list_agents",
    arguments: {}
  });
  console.log("Agents:", agentsResponse.content[0].text);
}

main();

2.7 Integration mit der Google Gemini API (Function Calling)

Tools von RubiConnect für Gemini-Modelle über das offizielle @google/genai-SDK bereitstellen:

import { GoogleGenAI } from "@google/genai";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";

async function main() {
  // 1. Verbindung zum RubiConnect MCP-Server aufbauen
  const transport = new SSEClientTransport(
    new URL("https://console.rubiconnect.com/api/mcp"),
    {
      headers: {
        "Authorization": "Bearer rc_live_ihr_echter_schluessel_hier"
      }
    }
  );
  const client = new Client({ name: "gemini-mcp-agent", version: "1.0.0" }, { capabilities: {} });
  await client.connect(transport);

  // 2. MCP-Tools laden
  const { tools } = await client.listTools();

  // 3. MCP-Tools in Gemini Funktionsdeklarationen umwandeln
  const geminiTools = tools.map((tool) => ({
    functionDeclarations: [{
      name: tool.name,
      description: tool.description,
      parameters: tool.inputSchema
    }]
  }));

  // 4. Gemini-Modell mit Function Calling abfragen
  const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
  const response = await ai.models.generateContent({
    model: 'gemini-2.5-flash',
    contents: 'Bitte listen Sie meine aktiven Messaging-Agents auf.',
    config: {
      tools: geminiTools
    }
  });

  // 5. Empfohlene Tool-Ausführung durchführen
  const call = response.functionCalls?.[0];
  if (call) {
    console.log(`MCP-Tool aufrufen: ${call.name}`);
    const result = await client.callTool({
      name: call.name,
      arguments: call.args
    });
    console.log("MCP-Ergebnis:", result.content[0].text);
  } else {
    console.log("Gemini-Antwort:", response.text);
  }
}

main();

System & Status

get_server_status

Ruft den Echtzeit-Systemstatus, die unterstützten Messaging-Kanäle und die MCP-Protokollversion des RubiConnect-Servers ab.

• Eingabeschema: object (keine Parameter)
• Ausgabeformat: Statusobjekt mit status, serverName, version, protocolVersion, supportedChannels und timestamp.

Markenidentitäten & Agents

list_agents

Gibt die für den Account registrierten aktiven Messaging-Agent-Profile (RCS & WhatsApp) zurück.

• Eingabeschema: object (keine Parameter)
• Ausgabeformat: Array von Agent-Profilen mit id, displayName, type und status.

get_agent_profile

Ruft detaillierte Konfigurationen, Verifizierungsstatus und Kanalkapazitäten für ein bestimmtes Agent-Profil ab.

• Parameter:
  • agentId (string, erforderlich): Eindeutige Agent-Profil-ID.
• Ausgabeformat: Detailliertes Agent-Objekt mit Verifizierungsmetadaten von Sinch/Meta, Webhooks und Kanalattributen.

Messaging & Chatverläufe

check_capability

Prüft, ob die Telefonnummer des Empfängers für Rich Messaging (RCS oder WhatsApp) bei einem bestimmten Agenten geeignet ist.

• Parameter:
  • recipient (string, erforderlich): Telefonnummer im E.164-Format.
  • agentId (string, erforderlich): Agent-Profil-ID zur Prüfung.
• Ausgabeformat: { capable: boolean, channel: "RCS"|"WHATSAPP", status: string }

send_message

Sendet eine Nachricht an einen einzelnen Empfänger ODER streamt einen Broadcast ohne Datenbank-Persistenz direkt aus einer entfernten HTTPS-CSV/JSONL-URL über RCS und WhatsApp.

• Parameter:
  • agentId (string, erforderlich): Eindeutige ID des sendenden Agent-Profils.
  • recipient (string, bedingt): Telefonnummer des Empfängers im E.164-Format (bei Einzelversand).
  • contactsUrl (string, bedingt): Signierte HTTPS-CSV- oder JSONL-URL zum direkten Streaming von Kontakten ohne Speicherung in der Datenbank.
  • urlFormat (string, optional): Format der contactsUrl ("csv" oder "jsonl", Standard "csv").
  • text (string, optional): Textinhalt der Nachricht.
  • mediaUrl (string, optional): Öffentliche URL der zu sendenden Mediendatei.
  • templateId (string, optional): ID einer vorkonfigurierten Vorlage.
  • allowSmsFallback (boolean, optional): Automatischer SMS-Fallback, falls der Empfänger kein RCS unterstützt.
  • suggestions (Array von Objekten, optional): Interaktive Aktionsschaltflächen (max. 4). Jedes Objekt enthält:
  • type (string, erforderlich): "reply", "url", "phone" oder "copy_code".
  • text (string, erforderlich): Button-Beschriftung (max. 25 Zeichen).
  • value (string, optional): Aktionswert (URL, Telefonnummer, Code oder Postback-Payload).
• Ausgabeformat: Statusobjekt mit messageId (Einzelversand) oder broadcastId und status: "streaming" (Remote-Streaming-Broadcasts).

get_inbox_messages

Ruft aktuelle Posteingangsnachrichten und Chat-Logs für ein bestimmtes Agent-Profil ab.

• Parameter:
  • agentId (string, erforderlich): Eindeutige Agent-Profil-ID.
  • limit (number, optional): Anzahl der zurückzugebenden Nachrichten (max. 100, Standard 20).
• Ausgabeformat: Array von Nachrichtenprotokollen mit id, recipient, content, status und date.

get_conversation_history

Ruft die letzten Dialogverläufe und Chat-Protokolle für eine bestimmte Kunden-Telefonnummer ab.

• Parameter:
  • recipient (string, erforderlich): Telefonnummer des Kunden im E.164-Format.
  • agentId (string, erforderlich): Agent-Profil-ID.
  • limit (number, optional): Anzahl der Dialogwechsel (Standard 20).
• Ausgabeformat: Chronologisches Array von Interaktionen mit Übertragungsrichtung und Zustellstatus.

Nachrichtenvorlagen (Templates)

list_templates

Ruft vorkonfigurierte Rich-Media-, Karten-, Karussell- und Textvorlagen für ein Agent-Profil ab.

• Parameter:
  • agentId (string, erforderlich): Agent-Profil-ID.
• Ausgabeformat: Array von Vorlagen inklusive Kartenausrichtung, Medienhöhe und interaktiven Buttons.

get_template_detail

Ruft die exakte Struktur, Ausrichtung und Aktionsschaltflächen einer spezifischen Vorlage ab.

• Parameter:
  • templateId (string, erforderlich): Vorlagen-ID.
  • agentId (string, erforderlich): Agent-ID.
• Ausgabeformat: Vollständige Vorlagenentität mit Kartenstrukturen und Button-Konfigurationen.

create_template

Erstellt eine neue Nachrichtenvorlage in der Account-Bibliothek. Unterstützt Rich-Cards (Bild, Titel, Text, Buttons), Karussells, Medien und reinen Text. Bei WhatsApp-Agents werden Meta-Formatierungsregeln automatisch geprüft und direkt zur Freigabe an die Meta Graph API übermittelt.

• Parameter:
  • name (string, erforderlich): Eindeutiger Vorlagenname (nur Kleinbuchstaben, Zahlen und Unterstriche).
  • text (string, erforderlich): Hauptinhalt der Nachricht mit Platzhaltern wie {{customer_name}}.
  • type (string, optional): "card", "text", "media" oder "carousel".
  • title (string, optional): Fette Überschrift für Karten.
  • mediaUrl (string, optional): Optionale Bild-, Video- oder Dokumenten-URL.
  • cardOrientation (string, optional): "VERTICAL" oder "HORIZONTAL".
  • mediaHeight (string, optional): "SHORT", "MEDIUM" oder "TALL".
  • agentId (string, optional): Zugeordneter Agent.
  • category (string, optional): Meta-Kategorie ("MARKETING", "UTILITY", "AUTHENTICATION").
  • language (string, optional): Sprachcode für WhatsApp, z. B. "de_DE", "en_US".
  • footer (string, optional): Optionaler Fußzeilentext (max. 60 Zeichen).
  • submitToMeta (boolean, optional): Bei WhatsApp-Agents: Sofortige Einreichung bei Meta (Standard true).
  • suggestions (Array von Objekten, optional): Interaktive Buttons (reply, url, phone, copy_code, flow).
• Ausgabeformat: Statusobjekt mit success, templateId, metaTemplateName und metaStatus ("PENDING" oder "APPROVED").

Kampagnen & Broadcasts

list_campaigns

Listet aktuelle Messaging-Kampagnen mit Live-Zustellstatus und Leistungsmetriken auf.

• Parameter:
  • agentId (string, optional): Kampagnen nach sendendem Agent-Profil filtern.
  • limit (number, optional): Maximale Anzahl an Kampagnen (Standard 20, max. 50).
• Ausgabeformat: Array von Kampagnenübersichten mit Live-Statistiken.

get_campaign_status

Ermittelt den Echtzeit-Zustellstatus: Gesendete, zugestellte, gelesene und fehlgeschlagene Nachrichten einer Kampagne oder eines Streaming-Broadcasts.

• Parameter:
  • campaignId (string, erforderlich): Eindeutige Kampagnen-ID.
  • agentId (string, optional): Agent-ID zur Bereichseinschränkung.
• Ausgabeformat: Objekt mit id, name, status, recipientSource und stats: { sent, delivered, read, failed }.

get_campaign_performance

Ruft detaillierte Engagement- und Performance-Analysen ab (Zustellrate, Leseraten, Interaktionsklicks).

• Parameter:
  • campaignId (string, erforderlich): Eindeutige Kampagnen-ID.
  • agentId (string, optional): Agent-ID.
• Ausgabeformat: Prozentuale Leistungsmetriken und Engagement-Statistiken.

create_campaign

Erstellt und versendet eine Messaging-Kampagne an gespeicherte Kontakte oder streamt diese direkt aus einer HTTPS-CSV/JSONL-URL mit null Datenbank-Persistenz.

• Parameter:
  • name (string, erforderlich): Aussagekräftiger Name der Kampagne.
  • agentId (string, erforderlich): ID des sendenden Agenten.
  • recipients (Array von Strings, optional): Liste von Empfänger-Telefonnummern.
  • contactsUrl (string, bedingt): Signierte HTTPS-CSV/JSONL-URL zum Streaming von Kontakten.
  • urlFormat (string, optional): Dateiformat ("csv" oder "jsonl").
  • recipientSource (string, optional): Zielgruppenquelle ("contacts" oder "remote_url").
  • contactListName (string, optional): Name der gespeicherten Kontaktliste.
  • text (string, optional): Haupttext der Kampagne.
  • templateId (string, optional): ID einer vorkonfigurierten Vorlage.
  • flowId (string, optional): ID eines interaktiven Flows.
  • sendNow (boolean, optional): Kampagne sofort einreihen und streamen (Standard true).
  • allowSmsFallback (boolean, optional): SMS-Fallback für Nicht-RCS-Empfänger aktivieren.
• Ausgabeformat: Statusobjekt mit campaignId, status: "Sending", recipientSource und channel.

Analytik & Medien

get_message_stats

Aggregiert das Nachrichtenvolumen, Fehlerraten und Leseraten über definierte Zeiträume.

• Parameter:
  • agentId (string, optional): Agent-ID.
  • timeRange (string, optional): "today", "yesterday", "7d" oder "30d" (Standard "today").
• Ausgabeformat: Aggregierte Kennzahlen mit Gesamtzahl gesendet, zugestellt, gelesen, fehlgeschlagen und Zustellprozentsatz.

search_images

Durchsucht die Workspace-Mediathek und externe Asset-Anbieter nach lizenzfreien Bildern anhand eines Suchbegriffs.

• Parameter:
  • query (string, erforderlich): Suchbegriffe (z. B. "kaffee", "sommer sale").
• Ausgabeformat: Array von Bildobjekten mit URLs, Vorschauen und Dimensionen.

messages://inbox

Der Posteingang des Workspaces enthält eine Liste der 20 aktuellsten Nachrichten (eingehende Kundenantworten und ausgehende Nachrichten).

• MIME-Typ: application/json
• Format: JSON-Array mit Nachrichtendetails: id, recipient, content, status und date.

Echtzeit-Aktualisierungsbenachrichtigungen

Verbundene MCP-Client-Agenten können die Ressource messages://inbox abonnieren:

1. Wenn ein Kontakt antwortet (z. B. eine Schnellantwort-Schaltfläche antippt), liefert der Netzbetreiber die Antwort an RubiConnect aus.
2. Der MCP-Server sendet sofort eine JSON-RPC-Benachrichtigung notifications/resources/updated mit dem Parameter uri: "messages://inbox" über den aktiven SSE-Stream.
3. Der KI-Agent empfängt diese Benachrichtigung und ruft resources/read auf, um die neue Antwort abzurufen und die Konversation interaktiv fortzuführen.

Salesforce Agentforce & Einstein Copilot

Salesforce Einstein und Agentforce unterstützen die Anbindung externer API-Dienste zur Ausführung von Tools.

1. Named Credentials: Richten Sie in Salesforce Setup ein Named Credential für https://console.rubiconnect.com/api/mcp mit dem Header X-Rubi-Key ein.
2. Apex Action Bridge: Implementieren Sie eine Apex-Klasse zur SSE-Verbindungsverwaltung und Übersetzung von JSON-RPC-Aufrufen, um diese als Einstein Copilot Actions bereitzustellen.
3. Trigger: Einstein Copilot kann dynamisch send_message oder create_campaign auslösen, wenn Vertriebsmitarbeiter den Assistenten beauftragen (z. B. "Sende die Preisübersicht per RCS an den Lead").

HubSpot Breeze & KI-Agenten

HubSpot-KI-Agenten können benutzerdefinierte Workflow-Erweiterungen nutzen, um externe Messaging-Aktionen abzufragen und auszulösen.

1. Benutzerdefinierte Aktionen: Registrieren Sie eine Custom Workflow Action im HubSpot-Entwicklerportal, die auf unsere API-Route verweist.
2. Workflow-Automatisierung: Tritt ein Ereignis ein (z. B. Lead-Status ändert sich auf "Kontaktiert"), ruft der HubSpot Breeze Agent das Tool send_message in RubiConnect auf, um eine interaktive Erstnachricht zu übermitteln.

Shopify KI-Agenten & Flow

Shopify-Shops können KI-Kundenservice-Agenten (z. B. basierend auf OpenAI Assistants oder LangChain) einsetzen, um transaktionale Nachrichten zu automatisieren.

1. Ereigniserkennung: Der KI-Agent erkennt einen abgebrochenen Warenkorb oder eine Bestellbestätigung.
2. Tool-Ausführung: Der Agent ruft send_message auf, um Bestell-Updates oder Rabattcodes direkt per RCS an das Smartphone des Kunden zu senden.