> ## Documentation Index
> Fetch the complete documentation index at: https://docs.langdock.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Datei-Input in MCP-Tools

> Nutze Dateien mit MCP-Tools in Langdock. Wenn ein MCP-Tool ein Datei-Input-Feld deklariert, löst Langdock Dateireferenzen automatisch in strukturierte FileData-Objekte auf.

Wenn ein MCP-Tool ein Input-Feld mit `format: "file"` deklariert, fängt Langdock die Dateireferenz des LLM automatisch ab und löst sie in ein strukturiertes `FileData`-Objekt auf – bevor der MCP-Server den Aufruf überhaupt erhält.

## Funktionsweise in Langdock

Wenn ein User eine Datei im Chat anhängt und das LLM darauf verweist (als Dateiname wie `report.pdf`, als Speicherpfad wie `attachment/<uuid>/<filename>` oder `/mnt/data/<filename>`), fängt Langdock diese Referenz ab und löst sie in ein vollständiges `FileData`-Objekt auf – bevor es an dein MCP-Tool weitergegeben wird.

### Die FileData-Struktur

Dein MCP-Tool erhält folgendes Objekt:

```typescript theme={null}
{
  fileName: string;       // ursprünglicher Dateiname, z. B. "report.pdf"
  mimeType: string;       // z. B. "image/jpeg", "application/pdf"
  base64: string;         // vollständiger Dateiinhalt, base64-kodiert
  size: number;           // Größe in Bytes
  lastModified: Date;
}
```

### Der `.meta({ format: "file" })`-Marker

Das entscheidende Signal für Langdock ist das Hinzufügen von `.meta({ format: "file" })` zu deinem Zod-Schema-Feld. Beim Speichern der MCP-Integration erkennt Langdock `format: "file"` im JSON-Schema und speichert das Feld als `FILE`-Typ. Bei der Ausführung löst Langdock die Dateireferenz in ein vollständiges `FileData`-Objekt auf und übergibt es an deinen MCP-Server.

## Datei-Input in deinem MCP-Server implementieren

Deklariere das Input-Feld als Zod-Objekt, das der `FileData`-Struktur entspricht. Verwende **nicht** `z.string()` – das MCP-SDK validiert Inputs vor dem Aufruf des Handlers, daher muss das Schema mit dem übereinstimmen, was es tatsächlich erhält:

```typescript theme={null}
server.registerTool(
  "process-file",
  {
    inputSchema: {
      file: z
        .object({
          fileName: z.string(),
          mimeType: z.string(),
          base64: z.string(),
          size: z.number().optional(),
        })
        .describe("Zu verarbeitende Datei")
        .meta({ format: "file" }), // teilt Langdock mit, die Referenz aufzulösen
    },
  },
  async ({ file }) => {
    const buffer = Buffer.from(file.base64, "base64");
    // verwende buffer, file.fileName, file.mimeType, etc.
    return {
      content: [{ type: "text", text: `Verarbeitet: ${file.fileName} (${file.size} Bytes)` }],
    };
  },
);
```

## Beispiel-Input und -Output

Wenn Langdock dein Tool aufruft, sendet es ein vollständig aufgelöstes `FileData`-Objekt:

```json theme={null}
{
  "file": {
    "fileName": "beispiel.txt",
    "mimeType": "text/plain",
    "base64": "SGVsbG8gd29ybGQ=",
    "size": 11
  }
}
```

Dein Tool kann dann Metadaten oder verarbeitete Ergebnisse zurückgeben:

```json theme={null}
{
  "success": true,
  "filename": "beispiel.txt",
  "mimeType": "text/plain",
  "sizeBytes": 11
}
```

## Beispielprojekt

Das Repository [langdock\_mcp\_file\_upload](https://github.com/matsjfunke/langdock_mcp_file_upload) ist ein minimaler, funktionierender MCP-Server, der den vollständigen Datei-Input-Flow demonstriert – von der Schema-Deklaration bis zur Verarbeitung des aufgelösten `FileData` im Tool-Handler.

## Verwandte Dokumentation

* [Langdock Cookbook](/de/developer/overview/cookbook) - Ausführbare MCP-Rezepte, unter anderem zu Datei-Uploads
* [MCP-Datei-Outputs](/de/using-langdock/guides/integrations/mcp/mcp-file-outputs) - Dateien aus MCP-Servern an Langdock zurückgeben
* [Model Context Protocol (MCP)](/de/using-langdock/guides/integrations/mcp/mcp) - Übersicht über MCP in Langdock
* [Langdock Agent MCP Server](/de/using-langdock/guides/integrations/mcp/langdock-agent-mcp-server) - Deine Langdock-Agenten als MCP-Tools bereitstellen

## FAQ

<AccordionGroup>
  <Accordion title="Wann sollte ein MCP-Tool Datei-Input akzeptieren?">
    Nutze Datei-Input, wenn das externe MCP-Tool eine Datei untersuchen oder verarbeiten muss, auf die der User in Langdock verweist. Das ist nützlich für Tools, die Dateien parsen, umwandeln, validieren oder in ein anderes System hochladen.
  </Accordion>

  <Accordion title="Was sollte ich prüfen, wenn eine Datei nicht an ein MCP-Tool übergeben wird?">
    Prüfe, ob das MCP-Tool ein Datei-Input-Feld deklariert, der User auf eine verfügbare Datei verwiesen hat, das Tool den Dateityp unterstützt und das Tool mit dem Datenformat umgehen kann, das Langdock sendet.
  </Accordion>
</AccordionGroup>