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.

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. Navigate to Account Settings and select API Keys.
3. Click Generate Token and copy the key to your clipboard. Tokens can be scoped to a specific workspace or issued read-only, so a given agent only sees what it needs.

The Tool Interface

The consolidated MCP toolset defines the operations any 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:

• list_workspaces: Retrieves the workspaces the authenticated token has permission to access, along with each workspace's ID and display name.
• search_files(query, workspace_id, top_k): Runs a hybrid search query across the workspace, returning semantic and keyword matches with file paths and citations.
• read_file_content(file_id): Fetches the content of a specific file, including its current version identifier.
• write_file_content(path, content, workspace_id): Edits or creates a file in a designated workspace folder, automatically creating a new entry in the version history rather than overwriting silently.
• create_metadata_view(schema_description, folder_path): Configures a new spreadsheet view that extracts structured data from files matching the given folder, based on a natural-language field description.

By standardizing these actions, the protocol lets coding models like Claude or GPT manage files without custom API glue for each application. Any client that speaks MCP can call the same tools; 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, Windsurf, 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, Windsurf, VS Code Copilot agent mode): these typically read MCP servers from a JSON settings block. Add an entry with "type": "streamableHttp", the https://api.fast.io/mcp URL, and a bearer token in the headers object:

{
  "mcpServers": {
    "company-brain": {
      "type": "streamableHttp",
      "url": "https://api.fast.io/mcp",
      "headers": {
        "Authorization": "Bearer your_fastio_api_token_here"
      },
      "disabled": false
    }
  }
}

• Command-line and terminal agents (Claude Code, Cline running in CLI mode): these register servers through a CLI command rather than a settings file:

claude mcp add company-brain https://api.fast.io/mcp --header "Authorization: Bearer your_fastio_api_token_here"

• 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 either the /mcp or /sse endpoint using the same bearer token scheme, 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 invokes the search_files tool exposed by 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 append-only audit 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 an append-only audit log of all workspace events. Every file upload, metadata extraction, search query, and tool execution is recorded in this log. This gives administrators a complete, tamper-proof 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 free, 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.

Fast.io has no permanent free plan, and all organizations require a paid subscription. Plans are structured to fit different team sizes:

• Starter: $29/mo.
• Business: $99/mo.
• Growth: $299/mo.

Every new organization starts with a 14-day free trial that requires a credit card. 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, native webhooks can notify external deployment pipelines, allowing teams to trigger automated builds when the agent updates the source files.