MCP in Rails

01 — WAS IST MCP

Das Protokoll zwischen Agent und Welt

Das Model Context Protocol (MCP) ist der offene Standard der definiert wie ein Sprachmodell externe Werkzeuge aufruft. Nicht als proprietäres API-Design einzelner Anbieter — als Protokoll, das jede Applikation implementieren kann.

Ein MCP-Server ist ein Prozess der Tools anbietet. Ein MCP-Client ist der Agent der diese Tools aufruft. Der Agent formuliert einen Tool-Call mit strukturiertem Input. Der Server führt ihn aus und gibt strukturierten Output zurück. Das ist alles.

Das Wichtige: MCP trennt Intelligenz (das Modell) von Capability (die Tools). Ein Modell kann FFmpeg nicht kennen — aber es kann einen Tool-Call an normalize_audio machen und das Ergebnis interpretieren. Die Rails-App definiert den Tool-Contract. Das Modell entscheidet wann es aufgerufen wird.

„MCP macht jede Rails-App zur Erweiterung eines Agenten."

MCP — PROTOKOLL-BASICS

Transportstdio · SSE · HTTP+SSE

Tool-Callname + typed input JSON

Tool-Resultcontent array (text / image)

Discoverytools/list RPC

SchemaJSON Schema per Tool

StandardAnthropic (open spec)

Ruby gemclaude-agent-sdk-ruby

Rails-Integrationdirekt im SDK dokumentiert

02 — ZWEI PROTOKOLLE, ZWEI SCHICHTEN

MCP ist Tool-Integration. ACP ist Agent-zu-Agent.

Das Ökosystem hat zwei Protokolle die oft verwechselt werden — weil sie ähnlich klingen aber verschiedene Schichten adressieren.

SCHICHT 1

MCP

Model Context Protocol

Agent ruft externe Tools auf. Der Kommunikationskanal zwischen Sprachmodell und Werkzeug. FFmpeg, Whisper, Datenbank, REST-API — alles wird zum MCP-Tool. Ein Server, viele Tools, ein Agent der sie orchestriert.

Claude → normalize_audio → FFmpeg → Result zurück zu Claude

SCHICHT 2

ACP

Agent Client Protocol

Agent ruft anderen Agenten auf. Nicht Tools, sondern vollständige Agenten-Systeme mit eigenem Kontext, eigenem Speicher, eigenen Tools. Zed Editor nutzt ACP um Claude-Agenten einzubinden — ein produktiver Code-Editor als erster Beweis dass das kein akademisches Protokoll ist.

Planungs-Agent → Spezialist-Agent → Ergebnis zurück

ACP (Agent-zu-Agent) ──→ agent-client-protocol-ruby
└→ MCP (Agent-zu-Tool) ──→ claude-agent-sdk-ruby
└→ Rails MCP-Server ──→ Tools (FFmpeg, Whisper, DB …)

03 — MCP IN RAILS — WIE ES AUSSIEHT

Ein MCP-Server in Rails: wenige Zeilen. Alles drin.

Der claude-agent-sdk-ruby-Gem bringt Rails-Integration direkt mit. Ein MCP-Server ist ein Ruby-Objekt das Tools registriert. Tools sind Methoden mit typisiertem Input-Schema und strukturiertem Output.

Das Beispiel rechts zeigt das Muster aus Tonecaster: ein Tool das eine Audiodatei analysiert. FFprobe läuft, das Ergebnis kommt als Hash, der Agent bekommt strukturierte Daten und entscheidet den nächsten Schritt.

„Das Tool ist der Contract. Der Agent entscheidet wann."

# app/mcp/dropzone_server.rb
class DropzoneServer < Mcp::Server

  tool :analyze_audio,
    description: "Analysiert eine Audiodatei",
    input_schema: {
      type: "object",
      required: ["path"],
      properties: {
        path: { type: "string" }
      }
    } do |params|

    result = AudioAnalyzer.run(params[:path])

    {
      duration:    result.duration,
      codec:       result.codec,
      bitrate_kbps:result.bitrate,
      sample_rate: result.sample_rate,
      id3_title:   result.title
    }
  end

end
    

04 — ANATOMIE EINES MCP-TOOLS

Jedes Tool ist eine Frage die ein Agent stellen kann.

Ein gut definiertes MCP-Tool hat fünf Teile. Wenn eines davon fehlt oder unklar ist, macht der Agent Fehler — nicht weil das Modell schlecht ist, sondern weil der Contract unscharf ist. Tool-Design ist API-Design für Sprachmodelle.

name

Maschinenlesbarer Bezeichner. Snake_case, präzise. normalize_audio, nicht processFile. Das Modell entscheidet anhand des Namens ob es das Tool aufruft.

description

Natürlichsprachige Erklärung was das Tool tut, was es braucht, was es zurückgibt. Das ist der Prompt für den Tool-Selector. Sorgfältige Beschreibungen reduzieren falsche Tool-Calls deutlich.

input_schema

JSON Schema für alle Parameter. Typen, required/optional, descriptions für jeden Parameter. Das Modell generiert den Input — ein präzises Schema reduziert Halluzinationen.

handler

Ruby-Block der den eigentlichen Code ausführt. Kann alles aufrufen: FFmpeg, Whisper, Active Record, externe APIs. Input ist validierter Hash. Output ist strukturierter Hash oder String.

error handling

Tool-Fehler kommen als strukturierter Error-Content zurück. Der Agent entscheidet dann was er macht — retry, Fallback, oder dem User melden. Crashes töten nicht den Agent-Run.

05 — PRAXIS: TONECASTER

32 Tools. Zwei Server. Ein Agenten-System.

Tonecaster betreibt zwei MCP-Server: den Dropzone-Server (32 Tools für Audio, Transkription, Content, Compliance, Discovery) und den Command-Server (29 Tools für direkte DB-Operationen).

Der Dropzone-Agent bekommt beim Start beide Server als MCP-Konfiguration. Er sieht 61 Tools. Er wählt aus welche er braucht. In einer typischen Episode benutzt er 6–8 davon — in der Reihenfolge die den Task am besten erledigt.

Das Wichtige: die Rails-App entscheidet nicht welche Tools in welcher Reihenfolge. Die Rails-App definiert was möglich ist. Der Agent entscheidet was sinnvoll ist.

TONECASTER MCP-ARCHITEKTUR

Dropzone-Server32 Tools, stdio Transport

Command-Server29 Tools, stdio Transport

AgentClaude Agent SDK 0.11

Sessionsclaude_session_id in Rails.cache

Kosten/Run$0.054 (8 Turns, 6 Tools)

WritersTurbo · SSE · Mock · AgentRun

BackgroundSolid Queue

# config/claude_agent.rb
ClaudeAgent.configure do |c|
  c.mcp_servers = [
    { name: "dropzone",
      command: "rails",
      args: ["mcp:dropzone"] },
    { name: "command",
      command: "rails",
      args: ["mcp:command"] }
  ]
end
    

06 — ACP — AGENT SPRICHT AGENT

Wenn ein Agent nicht genug ist.

MCP löst die Frage „wie ruft ein Agent ein Tool auf". ACP löst die nächste Frage: „wie ruft ein Agent einen anderen Agenten auf". Das ist kein akademisches Gedankenexperiment — Zed Editor, der populäre Code-Editor, hat ACP bereits implementiert um Claude-Agenten als externe Prozesse einzubinden.

Das agent-client-protocol-ruby-Gem (von denselben Autoren wie claude-agent-sdk-ruby) bringt ACP in den Ruby-Stack. Ein Planungs-Agent kann einen Spezialisierungs-Agenten aufrufen, dessen Ergebnis abwarten und weiterverarbeiten — ohne dass beide in derselben Rails-App laufen müssen.

„ACP ist der Unterschied zwischen einem Agenten und einem System von Agenten."

ACP Registry ── bekannte Agenten, ihre Fähigkeiten
↓
ACP Client ── agent-client-protocol-ruby
↓
Remote Agent ── eigenständiger Prozess, eigene MCP-Tools
↓ Result
Ursprungs-Agent ── verarbeitet weiter