Connect Seafile to Claude: Manage Directories & Share Assets

If you need to connect Seafile to Claude to automate file management, sync metadata, or generate secure share links, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's LLM function calls and Seafile's REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on connecting Seafile to ChatGPT or explore our broader architectural overview on connecting Seafile to AI Agents.

Giving a Large Language Model (LLM) read and write access to an enterprise file sync and share (EFSS) system like Seafile is an engineering challenge. You have to map highly specific repository structures to MCP tool definitions, handle multi-layered authentication mechanisms, and deal with strict rate limiting. Every time Seafile updates an endpoint or deprecates a parameter, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Seafile, connect it natively to Claude, and execute complex file management workflows using natural language.

The Engineering Reality of the Seafile API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Seafile's APIs is painful.

If you decide to build a custom MCP server for Seafile, you own the entire API lifecycle. Here are the specific challenges you will face:

Repo-Scoped Architecture and Commit IDs Unlike generic file systems where a simple absolute path is enough, Seafile isolates environments into Libraries (Repositories). Almost every API call requires a repo_id in addition to a file path. Furthermore, file mutations (like renaming, moving, or reverting) often require passing a specific commit_id to ensure consistency and prevent merge conflicts. Exposing this directly to an LLM without strict schema guidance often results in hallucinations, where the model invents a repo_id or forgets to include the commit_id entirely.

Two-Step Ephemeral Links for File Access Seafile does not allow you to simply execute a GET request and receive a massive binary payload directly from the standard API endpoints. Instead, it relies on ephemeral download and upload links. To read a file, the model must first request a download link, and then use a separate tool or HTTP client to fetch the data from that link. Building this orchestration into a custom MCP server requires intricate state management and secondary routing logic.

Dual Token Authentication Systems Seafile uses both Account-level Auth Tokens (for global operations) and Repo-level API Tokens (scoped to specific libraries). A custom server must intelligently manage which token to use for which tool, and handle expiration and renewal loops for both.

Rate Limits and 429 Errors Seafile instances (especially self-hosted or heavily multi-tenanted ones) enforce strict rate limits. A custom MCP server must handle HTTP 429 (Too Many Requests) errors gracefully. Note: Truto does not retry, throttle, or apply backoff on rate limit errors. When Seafile returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit info into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. The caller (or the agent framework) is strictly responsible for implementing retry and backoff logic based on these headers.

How to Generate a Seafile MCP Server

Truto's dynamic MCP server feature turns any connected Seafile account into an MCP-compatible JSON-RPC 2.0 endpoint. Rather than hand-coding tool definitions, Truto derives them dynamically from the integration's documented API resources. A tool only appears in the MCP server if it has a corresponding documentation entry - ensuring LLMs only access curated, well-described endpoints.

There are two ways to generate your Seafile MCP server URL: via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

If you are setting this up manually for Claude Desktop, the UI is the fastest route.

1. Log in to your Truto dashboard and navigate to the Integrated Accounts page.
2. Select your connected Seafile instance.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration. For example, you might want to restrict the server to only read methods to prevent Claude from deleting files.
6. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For platform engineers building multi-tenant AI products, you can generate MCP servers programmatically. Each server is scoped to a single integrated account, meaning the URL alone encodes the specific tenant's Seafile connection.

Send a POST request to /integrated-account/:id/mcp with your desired configuration:

curl -X POST https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude Seafile Connector",
    "config": {
      "methods": ["read", "list"],
      "tags": ["directory", "metadata"]
    }
  }'

The response contains the secure URL you will feed to Claude:

{
  "id": "mcp-789",
  "name": "Claude Seafile Connector",
  "config": { 
    "methods": ["read", "list"], 
    "tags": ["directory", "metadata"] 
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Technical detail: Raw tokens are never stored. Truto generates a random hex string, hashes it with an internal HMAC signing key, and stores it in high-speed KV infrastructure. The raw token in the URL is evaluated dynamically at request time.

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you must connect it to Claude. The process differs slightly depending on whether you are using the web interface or running Claude locally.

Method A: Via the Claude UI (Enterprise / Team)

If your organization supports web-based custom connectors:

1. Open Claude and navigate to Settings -> Integrations -> Add MCP Server.
2. Name your connector (e.g., "Seafile API").
3. Paste the URL you generated from Truto (https://api.truto.one/mcp/...).
4. Click Add. Claude will immediately issue an initialize JSON-RPC handshake to discover the available tools.

Method B: Via Manual Config File (Claude Desktop)

If you are using Claude Desktop for local agent development, you configure external servers using the Server-Sent Events (SSE) transport adapter.

Open your claude_desktop_config.json file (located in ~/Library/Application Support/Claude/ on macOS or %APPDATA%\Claude\ on Windows) and add the SSE command:

{
  "mcpServers": {
    "seafile_truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}

Restart Claude Desktop. The model now has full, authenticated access to your Seafile environment.

Essential Seafile MCP Tools

When Claude lists the tools available on the Truto MCP server, it receives schemas dynamically generated from Seafile's documentation. Here are the hero tools you should leverage for EFSS workflows.

Get Seafile File Details

Retrieves granular metadata about a specific file, including size, modification time, and permissions.

Tool name: list_all_seafile_files

Context: This tool requires a path. It returns attributes like can_preview, can_edit, and obj_id. Use this before attempting to modify or share a file to ensure it exists and the agent has the correct permissions.

"Claude, check the details for the file located at '/Contracts/2026/Acme_NDA.pdf' in Seafile. Tell me when it was last modified and its exact size."

List Directory Contents

Returns a structured list of all files and subfolders within a specific directory path.

Tool name: list_all_seafile_directories

Context: Excellent for discovery workflows. The LLM can use this recursively to traverse folder trees, locating specific assets without needing the exact path upfront.

"List all the files inside the '/Marketing/Q3_Campaign' directory. Filter out anything that isn't a PDF or image file."

Get Temporary Download Link

Generates a short-lived URL that can be used to stream the actual file contents.

Tool name: list_all_seafile_download_links

Context: Crucial for the two-step download process. The LLM requests the link via this tool, and then uses its native web-fetching capabilities or a secondary MCP tool to download the binary payload from the resulting URL.

"I need to review the Q1 Financials spreadsheet. Please get the download link for '/Finance/Q1_Report.xlsx' so you can read its contents."

Create a Share Link

Generates a public or password-protected share link for external collaboration.

Tool name: create_a_seafile_share_link

Context: This tool returns the token and the actual link. Use this to distribute files dynamically based on user requests.

"Generate a new share link for the folder '/Design_Assets/Logos'. Give me the URL so I can send it to the external agency."

List Repo Info

Fetches metadata about the current repository accessed via the active token.

Tool name: list_all_seafile_repo_info

Context: Because Seafile operations are heavily reliant on repo_id, this tool acts as a discovery mechanism to find the root ID and configuration of the library the agent is currently operating within.

"Before we start moving files, check the repository info and tell me the repo_id and name of the current library."

Search Files

Executes a keyword search across Seafile to locate matching documents.

Tool name: list_all_seafile_search_files

Context: Bypasses manual directory traversal by returning a list of id and result-specific attributes. Highly effective for RAG architectures or compliance audits.

"Search Seafile for any documents containing the keyword 'Project Titan'. List their exact paths and object IDs."

List Account Share Links

Returns a comprehensive audit log of all active share links generated by the authenticated account.

Tool name: list_all_seafile_account_share_links

Context: Vital for security operations. Returns the repo_id, path, token, and view_cnt (view count) for each link. If a link has expired or has excessive views, the agent can flag it.

"Audit all our active Seafile share links. List any links that have more than 50 views or are set to expire in the next 24 hours."

For the complete tool inventory, request schemas, and parameter definitions, view the Seafile integration page.

Workflows in Action

Connecting tools is just the foundation. The real power of MCP is how Claude orchestrates these tools to solve multi-step problems.

Scenario 1: Compliance File Audit and Secure Sharing

Persona: IT Administrator / Compliance Officer

"Search Seafile for the '2026 Vendor Security Policy'. Once you find it, check its metadata to confirm it was updated recently. Finally, generate a secure share link for it so I can send it to our new auditor."

Tool Execution Sequence:

1. list_all_seafile_search_files: Claude searches for "2026 Vendor Security Policy". The tool returns a JSON array containing the file's repo_id and path (e.g., /Policies/Security/2026_Vendor_Security_Policy.pdf).
2. list_all_seafile_files: Claude uses the discovered path to fetch metadata, reading the mtime (modification time) to verify it is up-to-date.
3. create_a_seafile_share_link: Claude passes the path to the share endpoint, generating a collaborative URL.

Outcome: The user receives a summary of the file's recency and the direct share URL, completing a compliance request in seconds without ever opening the Seafile UI.

sequenceDiagram
  participant User as User (Claude)
  participant MCPServer as MCP Server
  participant Upstream as Upstream API (Seafile)

  User->>MCPServer: list_all_seafile_search_files(q="2026 Vendor Security Policy")
  MCPServer->>Upstream: GET /api2/search/?q=...
  Upstream-->>MCPServer: Returns path & repo_id
  MCPServer-->>User: [File metadata JSON]
  
  User->>MCPServer: create_a_seafile_share_link(path="/Policies/...")
  MCPServer->>Upstream: POST /api/v2.1/share-links/
  Upstream-->>MCPServer: Returns token & link URL
  MCPServer-->>User: [Share Link URL]

Scenario 2: Two-Step Ephemeral Data Extraction

Persona: Data Engineer / Analyst

"I need to process the log files stored in '/Engineering/System_Logs/january_export.csv'. Please generate a download link for this file so we can ingest it."

Tool Execution Sequence:

1. list_all_seafile_files: Claude validates that the file exists and checks the size attribute to ensure it is not too large for processing.
2. list_all_seafile_download_links: Claude requests an ephemeral link for the file.

Outcome: Claude retrieves a temporary, authenticated URL (valid for a short window). The user (or downstream agent logic) can then curl that URL directly to stream the CSV data into their analytics pipeline.

Security and Access Control

Exposing an EFSS platform to an autonomous agent requires strict governance. Truto handles this at the MCP token generation layer, meaning security rules cannot be bypassed by the LLM.

• Method Filtering (config.methods): You can restrict the MCP server to specific categories. Passing "read" will expose get and list operations (like directory listings and searches) but strictly omit create, update, and delete tools. This is the safest way to deploy "read-only" agents.
• Tag Filtering (config.tags): If your integration configuration groups resources via config.tool_tags (e.g., tagging specific repositories as "public"), you can pass a tags array to only expose tools relevant to those tags.
• Extra Authentication (require_api_token_auth): By default, possession of the MCP URL grants access. By setting require_api_token_auth: true, the MCP router injects a conditional middleware requiring the client to also pass a valid Truto API token in the Authorization header.
• Time-to-Live (expires_at): You can create short-lived servers by passing an ISO datetime to expires_at. Truto registers this in Cloudflare KV and schedules a Durable Object alarm to aggressively hard-delete the token and KV cache at the exact expiration second.

flowchart TD
  A["Request Tool List<br>(Claude)"] --> B["Validate MCP Token URL"]
  B --> C{"require_api_token_auth?"}
  C -->|Yes| D["Validate Header Token"]
  C -->|No| E["Load Seafile Resources"]
  D --> E
  E --> F{"Method/Tag Filters Applied?"}
  F -->|Yes| G["Filter out unapproved endpoints"]
  F -->|No| H["Generate JSON Schemas"]
  G --> H
  H --> I["Return Tool Array to Claude"]

Wrapping Up

Connecting Seafile to Claude unlocks massive operational velocity. Instead of forcing teams to manually dig through deep folder hierarchies, check commit histories, or generate share links one-by-one, your AI agents can orchestrate the entire file lifecycle contextually.

Building a custom MCP server to handle Seafile's repo-scoped quirks, ephemeral download routines, and strict token requirements is a distraction from your core product. Truto abstracts this complexity away. It auto-generates the necessary JSON-RPC 2.0 schemas, proxies the API execution securely, and returns exactly the standardized headers your agents need to manage rate limits effectively.