Gib deinem KI-Agenten Dokumentbearbeitung – in unter 60 Sekunden

AgentDoc ist ein öffentlicher Model-Context-Protocol-Server (MCP). Jeder LLM-Agent, der MCP spricht – Gemini, Claude, GPT oder dein eigener – kann sich verbinden, authentifizieren und eine vollständige typisierte API zur Dokumentbearbeitung nutzen: lesen, schreiben, formatieren, navigieren, PDFs exportieren. Kein SDK zum Einbinden, kein Schema, das du auf deiner Seite pflegen musst, kein Mensch in der Schleife.

Diese Seite ist der kanonische Onboarding-Pfad für Agenten und die Menschen, die sie betreiben. Wenn du (oder dein Modell) einen funktionierenden Dokumenteneditor als Tool verfügbar haben willst, ist das hier alles, was du brauchst.

Schnellstart (ein HTTP-Aufruf)

Registriere ein isoliertes Agentenkonto und erhalte seinen API-Key in einer einzigen Anfrage. Kein Browser, keine E-Mail, kein Mensch in der Schleife. Jeder registrierte Agent ist sein eigener Nutzer mit eigenem Dokumentbereich – verschiedene Agenten sehen niemals die Dokumente der jeweils anderen.

curl -X POST https://agent-doc-edit.com/api/agents/register \
  -H "Content-Type: application/json" \
  -d '{"name": "my-research-agent"}'

# Response
# {
#   "user_id":        "...",
#   "username":       "agent_AbCdEfGh",
#   "name":           "my-research-agent",
#   "api_key":        "ak_...",          <-- shown ONLY here, store it
#   "api_key_prefix": "ak_AbCdEfGh",
#   "created_at":     "2026-04-25T..."
# }

Das war's. Verwende den api_key als Bearer-Token gegen /mcp/sse und der Agent verfügt über 35 typisierte Tools, um Dokumente zu lesen, zu schreiben, zu formatieren, zu paginieren und zu exportieren – vollständig auf sein eigenes Konto begrenzt.

Zwei Wege zur Authentifizierung

Option A – Agent registriert sich selbst (empfohlen für autonome Workflows)

Verwende POST /api/agents/register wie oben gezeigt. Der Agent erhält sein eigenes Nutzerkonto und seinen eigenen Dokument-Namensraum. Verschiedene Agenten kollidieren nie. Rate-Limit: 5 Registrierungen pro Stunde und IP. Das ist der richtige Pfad für Brief-Pipelines, Batch-Prozessoren, geplante Jobs und Multi-Agenten-Workflows.

Option B – Eigenes Nutzerkonto verwenden (für „gib meinem eigenen Assistenten Dokumentbearbeitung")

Öffne /app, melde dich an, Seitenleiste → „API-Keys für Agenten" → „+ Neuen Key erstellen". Der Key wird nur einmal angezeigt. Verwende ihn als Bearer-Token. Der Agent teilt sich dein Konto, deine Dokumente und deinen aktiven Dokumentstatus. Nützlich, wenn ein Co-Pilot-Agent neben dir an einem einzigen Korpus arbeiten soll.

Was abgerechnet wird (und was nicht)

Agenten bringen ihr eigenes LLM mit. Du bezahlst deinen Modellanbieter für Reasoning-Token. Wir sehen diese nicht, berechnen sie nicht und drosseln nicht danach. Unser Dienst hostet den MCP-Server, die Dokumentspeicherung und die Rendering-Pipeline. Die Spalte token_limit bei Agentenkonten ist als defensiver Schutzgurt auf 0 gesetzt: Falls irgendein zukünftiger Codepfad jemals versuchen würde, unseren internen Gemini-Agenten mit Agentenkonto-Authentifizierung auszuführen, würde er sich weigern – Agenten bleiben strikt auf dem MCP-Tool-Pfad.

Wichtig: Das ist autonom, nicht kollaborativ

Dieser Pfad ist für autonome Agenten-Workflows gebaut – dein Agent denkt mit seinem eigenen LLM, ruft unsere MCP-Tools direkt auf, bearbeitet Dokumente auf seinem eigenen Konto und exportiert ein Ergebnis. Dieselbe praxiserprobte Tool-Oberfläche, die unsere Sprach- und Text-Agenten in Produktion nutzen, treibt deinen Agenten an – aber dein Agent spricht nie mit unserem. Es gibt keinen KI-zu-KI-Hop, keinen internen LLM-Aufruf in deinem Namen, keine gemeinsame Sitzung mit unserem In-Browser-Editor.

Wenn du möchtest, dass ein Mensch und unser Sprach-/Text-Agent live gemeinsam bearbeiten, nutze /app direkt – das ist ein anderer Pfad. Wenn du möchtest, dass dein eigener Agent den Editor ohne Menschen bedient, ist der hier beschriebene MCP-Endpunkt die richtige Oberfläche.

Von jedem MCP-Client verbinden

Python (mcp client / Anthropic / Google ADK)

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

AGENTDOC_TOKEN = "ak_..."  # from POST /api/agents/register

async def edit_document():
    headers = {"Authorization": f"Bearer {AGENTDOC_TOKEN}"}
    async with sse_client("https://agent-doc-edit.com/mcp/sse",
                          headers=headers) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            # Workflow T (~35 tools) is applied automatically. Token is
            # injected from the Authorization header – do NOT pass `token`
            # in tool arguments.
            tools = await session.list_tools()

            # Create a document
            res = await session.call_tool("create_document",
                                          {"title": "My Report"})
            payload = json.loads(res.content[0].text)
            doc_id = payload["doc_id"]   # structured field, no regex

            # Insert content
            await session.call_tool("insert_string", {
                "doc_id": doc_id,
                "text":   "# Hello\n\nFirst paragraph.",
                "index":  0,
            })

            # Trigger PDF; response includes a self-describing fetch URL
            res = await session.call_tool("trigger_pdf_download",
                                          {"doc_id": doc_id})
            pdf_meta = json.loads(res.content[0].text)
            print(pdf_meta["pdf_url"])  # → "/api/doc//pdf"

TypeScript (Anthropic SDK)

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

const transport = new SSEClientTransport(
  new URL("https://agent-doc-edit.com/mcp/sse"),
  { requestInit: { headers: { Authorization: `Bearer ${TOKEN}` } } }
);
const client = new Client({ name: "my-agent", version: "1.0" }, { capabilities: {} });
await client.connect(transport);

const tools = await client.listTools();
const result = await client.callTool({
  name: "insert_string",
  arguments: { text: "Hello from my agent.", index: 0 }
});

curl (rohe Erkundung)

curl -N -H "Authorization: Bearer $TOKEN" \
     -H "Accept: text/event-stream" \
     https://agent-doc-edit.com/mcp/sse

Tool-Katalog – Workflow T wird automatisch angewendet

Externe Agenten (d. h. Anfragen, die mit einem ak_*-API-Key authentifiziert sind) werden automatisch auf die Tool-Oberfläche Workflow T beschränkt – den Pareto-optimalen Produktionsstandard, den unsere eigenen Sprach- und Text-Agenten verwenden. Du wendest diesen Filter nicht an; der MCP-Server wendet ihn serverseitig sowohl bei tools/list als auch bei tools/call an. So erhältst du das kuratierte Subset aus ~35 Tools (typisierte Primitive + Makros + beobachtendes Feedback zu Index-Verschiebungen), entfernst die Scratchpad- und FSM-Intent-Tools, die nicht zu T gehören, und schließt die atomaren „explodierten" Varianten aus, die nur unser Tool-Bloat-Benchmark verwendet. Jedes Tool hat ein JSON-Schema für seine Argumente und liefert eine strukturierte Antwort mit expliziten Erfolgs-/Fehlermarkierungen; indexverschiebende Operationen enthalten beobachtendes Feedback ("observation": "INDEX SHIFT – re-read before next mutation"), damit der Agent zwischen den Schritten geerdet bleibt.

Ein Dokument aus einer vorhandenen DOCX vorbefüllen

Die MCP-Tool-Oberfläche lässt deinen Agenten Dokumente von Grund auf erstellen. Für Workflows, die mit einer vorab erstellten Word-Datei beginnen – Vorlagen mit Firmenbriefkopf, Vertragsbausteine, ein eingehender Entwurf zur Überarbeitung – nimmt ein zusätzlicher One-Shot-HTTP-Endpunkt .docx-Uploads entgegen, erstellt ein frisches Document auf dem Konto des Agenten und schaltet es aktiv, sodass der nächste MCP-Aufruf auf dem importierten Inhalt landet:

# Upload a .docx; response is the new {id, title, ...}
curl -X POST https://agent-doc-edit.com/api/docs/import/docx \
  -H "Authorization: Bearer $API_KEY" \
  -F "[email protected]" \
  -F "title=Q3 Customer Letter"

Seitenumbrüche, Hyperlinks, Kopf-/Fußzeilen, Schriftarten, Farben und Zeilenabstände überstehen den Import alle. Vollständige technische Aufarbeitung: DOCX-Import – Word-Dokumente im Round-Trip.

Anwendungsfälle, die dein Agent autonom übernehmen kann

• Brief-Generierungspipeline. Der Agent erhält ein strukturiertes Event („entschuldige dich bei Kunde X für Verzögerung Y"), entwirft den Brief, formatiert ihn, exportiert ein PDF und hängt es an eine ausgehende E-Mail an.
• Berichtsgenerator. Der Agent liest eine CSV ein, fasst die Erkenntnisse zusammen, gliedert den Bericht in Überschriften, fügt ein Inhaltsverzeichnis ein, formatiert Schlüsselzahlen farbig und exportiert.
• Dokument-Refactoring. Der Agent liest einen vorhandenen Entwurf, ordnet Absätze neu an, wendet eine einheitliche Überschriftenhierarchie an, korrigiert uneinheitliche Terminologie mit einem einzigen macro_replace_all-Durchlauf und exportiert.
• Multi-Agenten-Workflows. Ein Planungsagent entscheidet, was geschrieben werden soll; ein Schreibagent ruft die AgentDoc-Tools auf, um das Artefakt zu erstellen; ein Prüfagent liest das Ergebnis und stößt Überarbeitungen an.
• Sprach-Übergabe. Ein Sprachagent nimmt gesprochene Anweisungen des Nutzers entgegen und übergibt strukturierte Aufgabenbeschreibungen an einen Textagenten, der die eigentlichen Dokumentoperationen gegen denselben MCP-Server ausführt.
• Vorlagen-Befüllung. Der Agent lädt eine .docx mit Firmenbriefkopf über /api/docs/import/docx hoch, füllt Platzhalterfelder mit macro_replace_text aus und exportiert das Ergebnis – der Mitarbeiter des Nutzers öffnet eine Word-Datei in genau dem Word, mit dem er begonnen hat.

Was das hier (konkret) agentenfreundlich macht

• Typisierte Tools, keine Freitext-Prompts. Jede Operation ist ein per JSON-Schema validiertes Tool. Der Agent kann ein Tool nicht „fast" aufrufen – die Argumente parsen oder eben nicht.
• Strukturierte Tool-Rückgaben. create_document liefert {"status":"success","doc_id":N,"title":...} – kein Regex über Prosa. trigger_pdf_download liefert ein selbstbeschreibendes {"pdf_url":"/api/doc/N/pdf","method":"GET"}, sodass ein einziges nachgelagertes HTTP GET die Bytes abruft.
• Automatische Token-Injektion. Der Bearer-Token aus deinem Authorization-Header wird automatisch in jeden Tool-Aufruf injiziert – deine Tool-Argumente bleiben frei von Auth. (Der interne Sprach-/Text-Agent nutzt eine ältere Konvention mit explizitem token-Argument; dieser Pfad bleibt aus Gründen der Abwärtskompatibilität unterstützt.)
• Stand-off-Formatierung. Der Agent schreibt nie rohes HTML. Formatierung ist ein typisierter Aufruf (format_text(..., format_type="color", format_value="blue")) – die Oberfläche, die am leichtesten zu halluzinieren ist, wurde entfernt.
• Ganzzahlige Dokument-IDs. Automatisch hochzählende Ganzzahlen, keine UUIDs – das eliminiert Zeichen-Drop-Halluzinationen, wenn der Agent eine ID zwischen Tool-Aufrufen weitergibt.
• Beobachtendes Feedback bei jeder Mutation. Rückgaben enthalten explizite Beobachtungen, wenn sich Indizes verschieben, sodass der Agent kein mentales Modell kumulativer Offsets führen muss.
• Visueller Echtzeit-Spiegel. Dasselbe Dokument, das der Agent bearbeitet, wird live unter /app gerendert. Nützlich für menschliche Überprüfung, Demos und multimodale Übergaben.
• Sprach-und-Text-Symmetrie. Der Sprachagent und der Textagent sehen exakt dieselbe Tool-Oberfläche. Wenn dein Agent als Text-Client funktioniert, funktioniert er auch als Sprach-Client.

Grenzen und ehrliche Einschränkungen

• Die LLM-Abrechnung liegt bei dir. Agenten bringen ihr eigenes Modell mit. Du bezahlst deinen Anbieter für Reasoning-Token. Unser Dienst hostet den MCP-Server und die Dokumentspeicherung; wir rechnen die LLM-Nutzung nicht ab und sehen sie nicht.
• Rate-Limit bei der Registrierung. 5 Agenten-Selbstregistrierungen pro Stunde und IP. Gedacht für legitime Bereitstellung, nicht für Massenmissbrauch.
• Tool-Aufruf-Rate. Weiches Limit pro Konto auf der Proxy-Schicht. Heute keine aggressive Drosselung, aber unbegrenzte Schleifen treffen irgendwann auf nginx-seitige Obergrenzen.
• Dokumentgröße. Der praktische Idealbereich liegt bei 1–50 Seiten (A4). Sehr große Dokumente (200+ Seiten) funktionieren, aber das Reasoning des Agenten verlangsamt sich, weil das Lese-Tool den vollständigen Zustand zurückgibt.
• Konto-Isolation. Jeder registrierte Agent ist sein eigener Nutzer. Dokumente sind nur diesem Nutzer zugeordnet – Agenten lesen oder schreiben nie kontenübergreifend. Um Dokumente bewusst zwischen Agenten zu teilen, teile den API-Key (Option B oben).
• Verfügbarkeit des Dienstes. Dies ist ein öffentlicher Dienst auf Forschungsniveau, kein produktives SLA. Wir streben eine hohe Verfügbarkeit an, geben aber keine formale Garantie.

Metadaten zur Auffindbarkeit

• llms.txt – eine Klartext-Sitemap für LLM-Crawler unter /llms.txt.
• OpenGraph / JSON-LD – jede Seite stellt, wo passend, WebAPI-/TechArticle-/FAQPage-Schema bereit.
• Stabile URLs – /agents ist kanonisch und wird sich nicht ändern.

Jetzt ausprobieren

Öffne den Editor in einem Tab, führe deinen Agenten in einem anderen aus. Die Bearbeitungen des Agenten erscheinen in Echtzeit auf demselben Bildschirm – nützlich zum Debuggen, für Demos oder für eine Mensch-+-Agent-Zusammenarbeit.

Technische Aufarbeitungen

• Tool-Granularität in LLM-Agenten – Designprinzipien für die MCP-Tool-Oberfläche, die dein Agent aufrufen wird.
• PDF- + DOCX-Export neu gebaut – wie die Export-Endpunkte das Bildschirm-Layout originalgetreu reproduzieren, wenn ein Agent einen Download auslöst.
• Patch Notes April 2026 – aktuelle Korrekturen an Renderer-/Dekorations-/Toggle-Semantik, auf die sich Agenten verlassen.