Company Brain MCP Server: A Reference for Tools, Transports, and Auth

Model Context Protocol (MCP) usage among developers increased by 150% in early 2026, marking a notable shift in how teams feed context to large language models [Gartner Infrastructure and Operations Report]. While copying and pasting raw database schemas, API specs, and text snippets was standard practice in the early days of generative AI, it has fast become an anti-pattern. Direct MCP connections reduce LLM context token waste by up to 80% compared to copy-pasting code [Model Context Protocol Community Benchmarks].

When a developer copy-pastes entire files into a chat window, they consume thousands of tokens on static text that the model might not need. This token waste leads to high API costs, slow response times, and model confusion. To address this, developers are turning to the Model Context Protocol. By establishing a central repository, developers configure a shared model context protocol workspace. This workspace acts as a single point of truth where coding assistants can query, read, and write files using natural language. Rather than hosting isolated local directories on individual workstations, teams use a centralized company brain mcp server. This setup bridges the gap between coding tools and organizational files, allowing agents to pull exact context on demand.

For the endpoints, transports, and auth behind a hosted example of this pattern, see the Fastio MCP integration guide.

• How to Test Fastio MCP Server Tools with PlaywrightTesting Fastio MCP server tools with Playwright lets developers verify AI agent integrations in a browser environment....
• Best MCP Server Generator Tools for 2026MCP server generator tools automatically scaffold Model Context Protocol servers from existing APIs, databases, or...
• Google Drive MCP Server in Python: Building Custom Tools vs Remote WorkspacesA Google Drive Python MCP server exposes Google Drive files and directory search to AI agents as standardized Model...
• MCP Server Middleware: Add Auth, Logging, and Transforms to MCP ServersMCP server middleware is a software layer that sits between MCP clients and servers. It lets you add authentication,...
• Open WebUI MCP Setup: Adding Model Context Protocol Tools to Self-Hosted AIOpen WebUI supports the Model Context Protocol natively through Streamable HTTP connections, allowing self-hosted...
• How to Implement MCP Server Rate LimitingMCP server rate limiting controls how often AI agents can invoke tools through a Model Context Protocol server. Without...

More on this subject: MCP and Model Context Protocol (244 guides)

Providing coding assistants with project context requires choosing a storage backend. Developers commonly start by pointing their tools to local directories. While this local-first approach is fast, it limits agent memory to a single workstation. When you switch devices or share the project with a colleague, the agent loses its context.

To solve this, some teams set up custom file storage using Amazon S3 or Google Cloud Storage. While cloud buckets offer durability, they require custom API integration and lack native document rendering. Other organizations rely on consumer cloud drives like Google Drive or Dropbox. These services work well for human co-editing but fail to provide structured access for AI agents. They lack native semantic indexing, forcing developers to build separate vector databases to search documents.

A centralized company brain provides an alternative. By deploying an mcp server for company brain access, teams consolidate their storage and intelligence layers. When files are imported from Google Drive, OneDrive, Box, or Dropbox via URL, they are indexed on arrival for keyword and semantic search. This hybrid search combines full-text accuracy with semantic meaning, allowing agents to find relevant document chunks without scanning whole folders. If an agent writes code or documentation, it deposits the output directly in the workspace, keeping a complete version history. This ensures that every file edit is tracked, enabling humans to restore previous versions if an agent makes an incorrect change.

The Fast.io company brain exposes itself to agents as a standard MCP server, not a bespoke API. Understanding its transport and auth model is the first step to wiring it into any client. The fastio mcp server setup supports two remote transport protocols: Streamable HTTP at /mcp and Server-Sent Events (SSE) at /sse. Streamable HTTP is the recommended default, since it runs bi-directional communication over a single connection and avoids the firewall issues that long-lived SSE connections sometimes hit behind corporate proxies. The SSE endpoint remains available for older agent frameworks that only implement the legacy MCP transport.

Authentication uses a bearer token rather than session cookies or OAuth redirects, which keeps it compatible with headless and CI-driven agents:

1. Log in to your organization dashboard at https://go.fast.io.
2. Go to Settings > Devices & Agents > API Keys and click Create API Key.
3. Copy the key to your clipboard; it is only displayed once. Tokens can be scoped to a specific workspace or issued read-only, so a given agent only sees what it needs.

The Tool Interface

In named mode, the consolidated MCP toolset defines the operations a connected client can call. Each tool accepts structured parameters and returns structured results, so agents don't need to parse HTML or guess at response shapes:

• org and workspace: Organization and workspace discovery, settings, and lifecycle, so an agent can find the workspaces its token can reach.
• storage (action search): Runs a hybrid search across the workspace, blending semantic and keyword matches into one ranked list with each hit's folder path.
• storage (action content) and download: Read a file's indexed text by page or passage, or get a download URL for the file itself.
• upload: Creates a file in a workspace folder, or replaces a same-name file in place while keeping the prior content as a recoverable version.
• metadata: Lists the workspace's extracted metadata fields and searches their values; storage (action metadata-extract) queues extraction for a file.

By standardizing these actions, the protocol lets coding models like Claude or GPT manage files without custom API glue for each application. Claude Code and Cursor get the lightweight code-mode set instead (auth, upload, search, execute, how-to) and reach the same operations through search and execute; the platform handles indexing, versioning, and storage underneath.

Give Every Agent Client a Governed Company Brain

Wire the Fast.io MCP server into Cursor, Claude Code, Devin Desktop, or any custom agent, with the same tools, transports, and audit trail across all of them. Start your 14-day free trial.

Start 14-Day Trial

Because the interface is standard MCP, the configuration shape is nearly identical across clients: a transport type, a URL, and an authorization header. The specifics vary slightly by client:

• Editor-integrated agents (Cursor, Devin Desktop (formerly Windsurf)): these typically read MCP servers from a JSON settings block (VS Code Copilot agent mode uses .vscode/mcp.json instead, with a top-level servers object and "type": "http"). Add an entry with the https://mcp.fast.io/mcp/code URL and sign in with OAuth in the browser, where the Review Permissions screen lets you select Read Only or Read & Write and choose which organizations and workspaces the connection can reach:

{
  "mcpServers": {
    "company-brain": {
      "url": "https://mcp.fast.io/mcp/code"
    }
  }
}

• Claude Code: registers servers through a CLI command rather than a settings file, then run /mcp inside Claude Code to sign in:

claude mcp add --transport http company-brain https://mcp.fast.io/mcp/code

• Custom and SDK-based agents: any agent built on the Anthropic, OpenAI, or open-source agent SDKs that supports MCP client libraries can connect directly to https://mcp.fast.io/mcp/code (or https://mcp.fast.io/mcp/tools for named tools) with an Authorization: Bearer <api key> header on the connection, without needing an editor at all. This is the path most teams use for headless pipelines, CI-triggered agents, and internally built automation.

Once connected, a client queries the Fast.io endpoint automatically. When you ask an agent to search for a file, it searches through the endpoint and retrieves matching file chunks from the shared workspace, which keeps token usage low compared to pasting entire files into a prompt. Learn more by reading the standard onboarding instructions or checking the developer storage page.

Once your coding assistants are connected to the central workspace, they can perform complex background tasks that require multi-document context. Instead of working on isolated files, agents can read, combine, and update documents across the entire workspace, keeping human team members in the loop.

Consider three common organizational workflows:

• Launch Kits: When launching a new feature, a coding agent can read technical specifications, search product features, and draft user-facing release notes. The agent writes these draft release notes directly to a shared folder in the workspace. The team can co-edit the document using Collaborative Notes, which support real-time co-editing for both people and agents.
• Renewal Briefs: Account managers can run an agent to prepare for client renewals. The agent queries client folders, searches past meeting notes, and extracts usage data. It compiles these details into a renewal brief, saving hours of manual lookup.
• Investor Updates: Startups can configure an agent to compile monthly reports. The agent scans financial tables, aggregates development tasks, and drafts an investor update.

These automated tasks stay reviewable because every write goes through the same version history and audit trail. For example, when an agent finishes writing a renewal brief, it lands in the shared folder as a new version rather than overwriting anything. A human reviewer opens the file, compares it against the prior version, and either accepts it or restores an earlier draft. Every file write, metadata extraction, and tool call is recorded in the activity log, so no agent output goes live without a visible, traceable record of what changed.

While semantic RAG search works well for finding paragraphs, organizations also need to extract structured data from their files. This is where Metadata Views come in. Unlike search indexes that summarize text, Metadata Views turn piles of documents into a live, structured database that agents can query.

Instead of writing custom OCR rules or training templates, developers describe the data they want to extract in natural language. The system designs a typed schema supporting Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time field types. It then parses files in the workspace (including PDFs, scanned pages, images, spreadsheets, and handwritten notes) and populates a sortable spreadsheet grid.

This structured extraction is highly useful across different industries:

• Legal: Extract counterparty names, contract execution dates, and renewal deadlines from legal agreements.
• Insurance: Pull policy numbers, coverage limits, and expiration dates from policy documents.
• Finance: Extract invoice line items, tax details, and total amounts from receipts.
• Media: AI-tag photos and videos with subjects, dominant colors, and creation metadata.

Because this extraction runs in the cloud workspace, agents do not need to download files or feed raw pages into their context. Coding assistants connected via MCP can query the spreadsheet data directly, running fast, token-efficient queries. You can also add new columns to an existing view without reprocessing the entire dataset, allowing your agents to update their data schemas as project requirements change.

Differentiating Extraction from Search

Intelligence Mode indexes the entire contents of documents for conceptual questioning. For instance, if an agent needs to write a launch kit, it uses semantic search to locate paragraphs explaining a new feature's design. This search process is optimized for text retrieval but is not designed for structured queries.

In contrast, Metadata Views serve as the structured extraction layer. If a project manager needs to track dozens of incident briefs, they do not want to query each document individually. Instead, they create a Metadata View. The system parses each incident brief, extracts the specific dates, severity scores, and root causes, and populates a single dashboard grid. This structured database allows agents to run aggregate queries, such as counting incidents by severity, without loading the full text of every report into their context window.

Deploying coding agents within an organization requires strict governance and auditability. If an agent operates with broad access, developers must be able to track every action, restrict folder access, and review changes. A shared cloud workspace provides these administrative controls natively.

First, Fast.io maintains a detailed activity log of workspace events. Every file upload, metadata extraction, search query, and tool execution is recorded in this log. This gives administrators a record of what files the agent accessed and what edits it made.

Second, granular permissions allow you to restrict agent access. You can define permissions at the organization, workspace, folder, or file level. This ensures that your coding assistant only accesses the project files it needs, keeping sensitive financial or legal folders restricted. If the agent needs to share specific deliverables with clients, it can create branded shares (Send, Receive, or Exchange) that feature custom logos, expiration dates, and password protection, without giving clients access to the main workspace.

Third, the platform handles human-agent collaboration through a structured ownership transfer flow. An agent can sign up, configure the workspace, run search indexing, and set up schemas. Once the workspace is ready, the agent transfers ownership of the organization to a human administrator.

All Fast.io organizations require a paid subscription. Plans are structured to fit different team sizes:

• Starter: $9.99/mo.
• Business: $49.99/mo.
• Enterprise: $199.99/mo.

Monthly plans start with a trial of up to 14 days (credit card required); annual plans have no trial. The owner can manage the billing and subscription details from their account panel. Once the human admin takes ownership, the agent can keep administrative access to continue writing code, while the organization owner retains full billing control. To start the handoff, you can sign up for a trial on the Fast.io pricing page and configure your developer storage options.

Finally, while the platform provides strong workspace security, it does not claim compliance certifications. Organizations requiring specialized certifications should manage sensitive records using internal storage systems, using the shared workspace for collaborative coding and development tasks. When files change, a listener on the WebSocket events feed can notify external deployment pipelines, allowing teams to trigger automated builds when the agent updates the source files.