Connect Seafile to ChatGPT: Search Files, Repos & Metadata

If you want to connect Seafile to ChatGPT so your AI agents can search file contents, query custom metadata records, and manage repository access, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and Seafile's REST API. You can either spend weeks building, hosting, and maintaining a custom MCP server, or you can use a managed infrastructure layer that handles the boilerplate for you. If your team uses Claude instead of OpenAI, check out our guide on connecting Seafile to Claude, or explore our broader architectural overview on connecting Seafile to AI Agents.

Giving a Large Language Model (LLM) read and write access to a self-hosted or cloud file synchronization platform like Seafile is a significant engineering challenge. You have to handle unique authentication flows, map massive JSON schemas for file operations, and write logic for path-based tree traversal. Every time an endpoint shifts or a schema updates, you have to redeploy your server code. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Seafile, connect it natively to ChatGPT, and execute complex file and metadata workflows using natural language.

The Engineering Reality of the Seafile API

A custom MCP server is a self-hosted integration layer. While Anthropic's open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against vendor APIs is painful. If you decide to build a custom MCP server for Seafile, you own the entire API lifecycle. You are not just dealing with generic HTTP requests - you are dealing with Seafile's specific architectural quirks.

Here are the specific integration challenges that break standard REST assumptions when working with Seafile:

Path-Based Traversal vs Global IDs Unlike Google Drive or Dropbox, which rely heavily on globally unique file IDs for operations, Seafile's API is heavily dependent on the combination of a repo_id (the library) and a literal string path. If an LLM wants to rename a file, move a folder, or fetch a file's history, it must maintain the exact directory path state in its context window. Your MCP server must explicitly define schemas that force the LLM to pass both the repo_id and the path correctly. If the LLM hallucinates a trailing slash or drops the repository context, the API call will fail with a 404.

The Metadata View Abstraction Seafile is not just a dumb file store - it features a robust metadata system that acts like a relational database overlaid on your libraries. You cannot simply "get metadata" for a file. You have to first query the metadata views (list_all_seafile_metadata_views), identify the correct view ID for your specific table layout, and then query the records for that view (list_all_seafile_metadata_records). For an AI agent to extract tabular data from Seafile, your tool descriptions must teach the LLM this two-step relational query process.

Strict Rate Limits and Error Handling Seafile instances, particularly shared cloud environments, enforce strict rate limits to prevent abuse. If an AI agent attempts to iterate through a massive directory tree recursively, it will rapidly hit HTTP 429 Too Many Requests errors.

Note on rate limit architecture: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Seafile API 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 (your agent framework or the OpenAI client) is strictly responsible for implementing retry and exponential backoff logic. Do not expect the infrastructure layer to absorb these errors silently - if your agent is not configured to handle 429s, the tool call will fail and the LLM will hallucinate a response.

How to Generate an MCP Server for Seafile

Rather than hand-coding tool definitions, Truto derives them dynamically from the integration's documented API endpoints, ensuring only curated, well-described endpoints are exposed to the LLM.

Each MCP server is scoped to a single integrated account (a connected instance of Seafile). The server URL contains a cryptographic token that encodes the account, what tools to expose, and optional expiration limits.

You can create this MCP server via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

For quick testing and manual deployments, the UI is the fastest path:

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Seafile instance.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can filter by methods (e.g., restricting the server to read operations only) or filter by tags.
5. Click Create and copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For production workflows, you can generate MCP servers programmatically. This validates that the integration has tools available, generates a secure hashed token, stores it in Cloudflare KV, and returns a ready-to-use URL.

Make a POST request to /integrated-account/:id/mcp:

const response = await fetch('https://api.truto.one/integrated-account/<seafile_account_id>/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_TRUTO_API_KEY>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Seafile Read-Only MCP",
    config: {
      methods: ["read"], 
      tags: ["files", "metadata"]
    },
    expires_at: "2026-12-31T23:59:59Z"
  })
});
 
const mcpServer = await response.json();
console.log(mcpServer.url); // https://api.truto.one/mcp/...

This URL is fully self-contained. It handles all OAuth token refreshes and authentication against the Seafile API automatically.

How to Connect the MCP Server to ChatGPT

Once you have your Truto MCP Server URL, you must register it with your LLM client so the model can discover the available tools via the tools/list JSON-RPC handshake.

Method A: Via the ChatGPT UI

If you are using ChatGPT directly:

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode (MCP support is currently behind this flag).
3. Under MCP servers / Custom connectors, click to add a new server.
4. Name: Enter a label like "Seafile API".
5. Server URL: Paste your Truto MCP Server URL.
6. Click Save. ChatGPT will immediately ping the endpoint, execute the initialization handshake, and list the available Seafile tools.

(Note: If you are connecting Claude Desktop instead, navigate to Settings -> Integrations -> Add MCP Server, paste the URL, and click Add).

Method B: Via Manual Config File (Local Agents)

If you are running a local agent framework, Cursor, or Claude Desktop via file configuration, you can wire up the server using the official SSE transport package. Add the following to your MCP configuration file (e.g., claude_desktop_config.json or your agent's config):

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

Hero Tools for Seafile

Truto automatically generates highly specific, snake_case tools based on Seafile's resources. When an LLM framework calls a tool, all arguments arrive as a flat object. Truto's router splits them into query and body parameters dynamically.

Here are the highest-leverage hero tools for automating Seafile.

list_all_seafile_search_files

This is the primary discovery tool. Because Seafile relies heavily on path-based architecture, an LLM often needs to search by keyword first to discover the exact repo_id and path of a file before it can operate on it.

"Search my Seafile account for any documents containing the keyword 'Q3_Financial_Audit' and return the file paths and repository IDs."

list_all_seafile_directories

This tool allows the LLM to traverse the folder structure of a specific repository. It returns the type, ID, name, modification time, and parent directory for all items within the requested path.

"List all the files and folders located in the path '/Internal/Engineering/Architecture' inside repository ID 'abc-123-def'."

list_all_seafile_files

Once the LLM knows the path of a file, this tool retrieves detailed metadata about that specific file, including size, modification time, preview capabilities, and edit permissions.

"Get the detailed file information for '/Internal/Engineering/Architecture/system_design.md' in repository 'abc-123-def' so I can check when it was last modified."

list_all_seafile_download_links

This tool is critical for Retrieval-Augmented Generation (RAG) and document ingestion workflows. It generates a temporary download URL for a file. The agent can then use a standard HTTP GET request against that URL to read the raw contents of the file into its context window.

"Generate a download link for the file '/Marketing/2026_Campaign.pdf' in repository 'xyz-789'."

list_all_seafile_metadata_records

This tool accesses Seafile's database-like metadata layer. By providing a view_id, the LLM can pull structured rows of data associated with files in a library, effectively treating Seafile like a headless CMS or tabular database.

"Fetch all metadata records for view ID 'view-456' so I can see the status of all currently open legal contracts."

create_a_seafile_share_link

This tool enables outbound sharing. It creates a public or restricted share link for a specific library or folder, returning the token, URL, and path details.

"Create a share link for the folder '/External/Client_Deliverables/Acme_Corp' and give me the URL so I can draft an email to the client."

list_all_seafile_file_history

For auditing and version control, this tool lists the commit history of a specific file, returning the commit IDs, creation times, creator names, and emails.

"Retrieve the file history for '/HR/Policies/Remote_Work.pdf' and tell me who made the last three updates."

For the complete inventory of available Seafile tools and their exact JSON schemas, visit the Seafile integration page.

Workflows in Action

Providing individual tools is necessary, but the real power of MCP is agentic orchestration - allowing the LLM to string together multiple tool calls to solve a complex goal.

Workflow 1: Auditing Project Documentation

In this scenario, an IT admin asks ChatGPT to audit a specific project document, figure out who last touched it, and read its contents.

"Find the document named 'Project_Titan_Spec', tell me who updated it last, and summarize the contents of the file."

sequenceDiagram
    participant User as User
    participant ChatGPT as ChatGPT
    participant Truto as Truto MCP
    participant Seafile as Seafile API
    User->>ChatGPT: "Find 'Project_Titan_Spec', who updated it, and summarize it."
    ChatGPT->>Truto: Call list_all_seafile_search_files (q: "Project_Titan_Spec")
    Truto->>Seafile: GET /api/v2.1/search/?q=...
    Seafile-->>Truto: Results
    Truto-->>ChatGPT: repo_id, path
    ChatGPT->>Truto: Call list_all_seafile_file_history (repo_id, path)
    Truto->>Seafile: GET /api/v2.1/repos/.../file/history/
    Seafile-->>Truto: Commit history
    Truto-->>ChatGPT: Creator, time, commit_id
    ChatGPT->>Truto: Call list_all_seafile_download_links (repo_id, path)
    Truto->>Seafile: GET /api/v2.1/repos/.../file/
    Seafile-->>Truto: Download URL
    Truto-->>ChatGPT: url
    ChatGPT->>ChatGPT: HTTP GET URL (internal fetch)
    ChatGPT-->>User: "The file was last updated by Alice. Here is the summary..."

What happens:

1. ChatGPT calls list_all_seafile_search_files to resolve the keyword into a concrete repo_id and path.
2. It calls list_all_seafile_file_history using those parameters to identify the last committer.
3. It calls list_all_seafile_download_links to get a temporary URL.
4. It reads the URL contents, analyzes the text, and returns the final answer to the user.

Workflow 2: Extracting Structured Metadata

If a team is using Seafile's metadata views to track asset approvals, the agent can query the system like a database.

"Look up the metadata view for 'Approved Assets' and tell me which files were marked as approved this week."

flowchart TD
    A["User: Tell me which files were<br>marked approved this week"] --> B["list_all_seafile_metadata_views"]
    B -->|"Returns view definitions"| C["LLM identifies view_id<br>for 'Approved Assets'"]
    C --> D["list_all_seafile_metadata_records<br>(view_id)"]
    D -->|"Returns structured rows"| E["LLM filters by date<br>and responds to user"]

What happens:

1. ChatGPT calls list_all_seafile_metadata_views to get the schema of the current database.
2. It inspects the result array to find the internal _id for the "Approved Assets" view.
3. It calls list_all_seafile_metadata_records passing that _id.
4. It parses the returned JSON rows, filters by the _mtime or custom date field, and presents the list to the user.

Security and Access Control

Exposing a corporate Seafile instance to an LLM introduces risks. You do not want a hallucinating model to execute bulk deletes across your repositories. Truto provides granular security controls at the MCP server level:

• Method Filtering (config.methods): Restrict the server to specific operation types. Setting methods: ["read"] ensures the server will only expose GET and LIST endpoints. Operations like create_a_seafile_directory or seafile_files_bulk_delete will be stripped from the tool list entirely.
• Tag Filtering (config.tags): Group tools by functional area. You can restrict the MCP server to only expose tools tagged with metadata or search, isolating the agent from core file modification resources.
• Extra Authentication (require_api_token_auth): By default, possessing the MCP URL grants access to the tools. Setting this flag to true forces a second layer of authentication. The connecting client must also pass a valid Truto API token in the Authorization header, ensuring only authenticated systems can invoke tools.
• Time-to-Live (expires_at): For temporary workflows (e.g., granting a contractor's local agent access to a specific repository), you can set an ISO datetime. Once reached, Truto's background alarm handlers automatically purge the token from Cloudflare KV and the database, instantly revoking access.

If you want your AI agents to interact with Seafile - navigating directories, reading files, and extracting metadata - you need a robust, managed integration layer. Hardcoding these API calls, maintaining JSON schemas for MCP, and writing your own infrastructure for OAuth tokens and KV storage is a massive distraction from building your core product.