Red MCP Server
Red is an open-source Model Context Protocol (MCP) server that connects AI assistants and MCP clients to Big Red Cloud accounting data through a set of controlled MCP tools.
Supported customer platforms today are ChatGPT, Claude, and Mistral (including Vibe). Other MCP clients may work technically, but they are not treated as officially supported platforms. Red uses platform detection only for anonymous operational telemetry (see Privacy-safe telemetry).
Instead of calling the Big Red Cloud REST API directly, users work in plain language. The server translates requests into structured API calls and applies safety checks around anything that changes data.
With Red, a connected user can:
- Review Big Red Cloud data with read-only lookups (customers, suppliers, products, invoices, quotes, nominal reports, and more).
- Review before posting — see a plain-English preview of new records before anything is written to Big Red Cloud.
- Create, update, or delete records only after explicit confirmation.
- Ask Big Red Cloud how-to and training questions — Red answers using official support articles, customer documentation, screenshots, and webinar resources. These help tools do not require a connected company.
Why open source?
We believe AI infrastructure should be transparent. Customers should be able to inspect the software that connects their accounting data to AI assistants.
Our competitive advantage is not the connector itself; it is our accounting platform, our expert bookkeeping advice, our customer experience, and the value we build on top of it.
By open-sourcing Red, we hope to encourage trust, community contributions, and wider adoption of open standards.
Features
- Secure company connection flow (one-time connection page; no credentials in chat)
- Pre-confirm validation of company connection credentials on the connection page (single-company form or multi-company CSV upload)
- Partial connection results — invalid keys are rejected before confirm and reported in
failedCompanies
- Hosted HTTP
connectionRef / activeConnectionRef so MCP clients can silently reuse a confirmed connection across supported session changes; kept in tool JSON, not shown to end users
- Privacy-safe anonymous operational telemetry (platform, environment, tool name, connected-company count) — see docs/TELEMETRY.md
- Company readiness check (
brc_company_readiness_check) for connected companies
- Read-only Big Red Cloud lookups
- Customer, supplier, product, sales rep, VAT, and analysis category tools
- Sales quotes, invoices, credit notes, purchases, payments, and cash tools
- Preview-before-posting confirmation flow for create, update, delete, batch, and email actions
- VAT and transaction safety checks
- Sales invoice safeguards, including multi-line generated-reference validation, Gross Price Entry
priceBasis handling, Sales VAT category validation, placeholder product ID blocking, and CR analysis category confirmation
- Session audit log of writes made through the MCP session
- Official Big Red Cloud help answers from Freshdesk articles, customer documentation, screenshots, and webinars — no company connection required
- Local stdio and hosted HTTP transports
Security and safety model
Red is designed so that AI-driven access to accounting data stays controlled and auditable.
- No credentials in the repository. Company connection credentials and secrets are never committed. Configuration is supplied at runtime through environment variables.
- No credentials in chat. Company connection credentials must not be pasted into chat. Companies are connected through the secure Red connection page, where credentials are entered directly — not in the chat window.
- Session-scoped connections. A connected company stays available for about the configured session duration and is held in session memory (or an optional shared connection store in hosted deployments). Where supported, connection handling is resilient across MCP session rotation so clients can reuse
connectionRef / activeConnectionRef without asking the user to reconnect.
- Pre-confirm validation. Company connection credentials submitted on the connection page are validated against Big Red Cloud before they are stored. Invalid or expired credentials are not saved; they appear in
failedCompanies at confirmation time.
- Credential invalidation. Only confirmed authentication failures clear a stored company credential. Endpoint, validation, permission, timeout, and server failures are not treated as an expired API key.
- User-facing presentation.
connectionRef, session IDs, and other MCP diagnostics are for tool arguments only. Assistants must not show redconn_… values or internal connection metadata to normal users unless dev mode is enabled or the user explicitly asks for technical details.
- Configurable session duration. How long connections last is controlled by
BRC_API_KEY_TTL_MINUTES. User-facing wording (connection page, getting-started text, connection status) is derived from that value — not hardcoded.
- Explicit confirmation for writes. Create, update, delete, batch, and email actions require an explicit confirmation flag after a preview before posting has been shown.
- Preview before posting. The first call to a write tool returns a payload preview rather than performing the action. Nothing is written to Big Red Cloud until you confirm.
- Read and write are separated. Read-only lookups are clearly distinct from actions that change data.
- Audit log. Writes made through the MCP session are recorded in a session audit log; read-only calls are not logged.
- Deployment flags. Update, delete, email, batch, and operator/dev tools can each be disabled per deployment, in which case the matching tools return a permission message instead of calling Big Red Cloud.
Sales invoice safety checks
Sales invoice handling includes:
- Gross Price Entry requires an explicit
priceBasis of gross or net so VAT is never guessed.
- Sales VAT rates only. Sales invoices must use a Sales VAT category; purchase VAT rates are blocked, even when the percentage matches.
- Placeholder product IDs (
productId 0 and 1) are treated as placeholders and blocked before preview-before-posting and post.
- Multi-line generated-reference invoices (
brc_create_sales_invoice_gen_ref) require each productTrans line to include its own acEntries analysis allocation. Line net/VAT/gross reconciliation, analysis allocation totals, header totals, and required product/VAT/analysis fields are validated before posting; failures return structured field-level errors.
note defaults to the customer name unless a note is explicitly provided, and is never set to a product name.deliveryTo is included only when a delivery address is explicitly provided.- Plain-language results. Technical HTTP status codes are translated into plain-language messages for users.
Architecture
Two entry points share one tool registry:
| Entry | File | Transport | Use case |
|---|
| Local stdio | src/index.ts | StdioServerTransport | An MCP client spawns node build/index.js |
| Hosted HTTP | src/remote.ts | Streamable HTTP on /mcp | npm run start — one MCP server per session |
Key shared modules:
src/server.ts — MCP server factory and stdio singletonsrc/register_all_tools.ts — central tool registration; wraps the server so disabled skills register a permission-message blocker instead of the real tool, and so write tools get preview-before-posting/confirmation handlingsrc/config/server_config.ts — deployment skill gating driven by the BRC_ALLOW_* flagssrc/config/mcp_config.ts — MCP server instructions, connection-safety rules, and connectionRef presentation rulessrc/shared.ts — Big Red Cloud HTTP client, session-scoped connections, audit log, and helperssrc/read_connection_metadata.ts — connection status metadata echoed on tool responses (including activeConnectionRef for hosted clients)src/auth/connection_presentation.ts — user-facing TTL wording and assistant presentation hintssrc/auth/credential_validation.ts — BRC read validation before storing company connection credentialssrc/guards/ — transaction, reference, VAT category, product line, and write-confirmation safety checkssrc/auth/ — secure connection flow, connection store (memory or Cosmos), connection page, and credential persistence
<<<<<<< HEADsrc/telemetry/ — anonymous client/session identity and platform detection for hosted operational telemetry
=======
company-github/main
src/brc-edu/ — Freshdesk articles, customer documentation, webinar indexes, screenshots, and unified help searchsrc/edu/ — shared help-resource loading, enrichment, workbook parsing, and storage configurationsrc/tools/edu/ — read-only help tools: brc_find_help_resources and brc_get_help_resource_details
Domain logic lives under src/tools/, with generic create/update/delete/list/batch helpers in src/tools/general/.
Technology
- TypeScript / Node.js (ES modules)
@modelcontextprotocol/sdk- Zod for tool input validation
- Express + Streamable HTTP for hosted mode
Requirements
- Use a current LTS version of Node.js.
- npm (bundled with Node.js).
Installation
npm install
npm run build
If a .env.example file is provided, copy it to .env and adjust the values:
Never commit your .env file or any real credentials.
Running
Hosted HTTP server:
Local stdio server:
Opening the HTTP endpoint in a browser without an MCP session returns an error — that is expected.
MCP client configuration
Local stdio (the client spawns the process):
{
"mcpServers": {
"red-mcp-server": {
"command": "node",
"args": ["build/index.js"],
"env": {
"BRC_API_BASE_URL": "https://app.bigredcloud.com/api"
}
}
}
}
Hosted HTTP (production):
For the hosted Big Red Cloud Red service, customers should use:
https://red.bigredcloud.com/mcp
{
"mcpServers": {
"red-mcp-server": {
"url": "https://red.bigredcloud.com/mcp"
}
}
}
Hosted HTTP (local development):
{
"mcpServers": {
"red-mcp-server": {
"url": "http://localhost:3000/mcp"
}
}
}
Development and regression testing
| Script | Command | Purpose |
|---|
| Build | npm run build | Compile TypeScript to build/ |
| Dev HTTP | npm run dev | Run the HTTP server from source with tsx |
| Dev stdio | npm run dev:local | Run the stdio server from source with tsx |
| All tests | npm test | Build, then run the full test suite |
| Unit tests | npm run test:unit | Unit tests only |
| Security tests | npm run test:security | Security-focused tests |
| Config tests | npm run test:config | Deployment/config tests |
| Integration tests | npm run test:integration | Integration tests |
| Production audit | npm run audit:prod | npm audit for production dependencies |
Tests cover the safety guards described above, including sales invoice checks, transaction date validation, the secure connection flow (CSV validation, partial confirm, credential invalidation), connectionRef presentation rules, TTL wording, and response wording.
Environment variables
Configure the server with environment variables (for example via a .env file). The values below are examples only and must never contain real secrets or be committed.
# Big Red Cloud API base URL
BRC_API_BASE_URL=https://app.bigredcloud.com/api
# HTTP port for hosted mode
PORT=3000
# Public URL for the secure /connect page (required for hosted deployments)
BRC_PUBLIC_BASE_URL=https://your-mcp-host.example.com
# MCP session binding lifetime (minutes)
BRC_MCP_SESSION_TTL_MINUTES=120
# How long stored company credentials stay valid (minutes).
# Drives credential expiry and user-facing duration wording (e.g. 240 → "about 4 hours").
BRC_API_KEY_TTL_MINUTES=120
# Rate limiting (requests per minute per IP)
BRC_RATE_LIMIT_REQUESTS_PER_MINUTE=300
# SHA-256 hashes of blocked API keys, comma separated (hashes only, never raw keys)
BRC_API_KEY_BLACKLIST_SHA256=
# Hosted connection persistence (optional)
# memory = in-process (local/Cursor); cosmos = shared store for multi-instance HTTP
RED_CONNECT_CONNECTION_STORE=memory
RED_CONNECT_COSMOS_CONNECTION_STRING=
RED_CONNECT_COSMOS_DATABASE=red-connect
RED_CONNECT_COSMOS_CONTAINER=connections
RED_CONNECT_ENCRYPTION_KEY=
# Set automatically when running the HTTP server (remote.ts)
RED_CONNECT_HTTP_MODE=true
Deployment skill flags control which categories of tools are active. When a flag is off, the matching tools return a permission message instead of calling Big Red Cloud:
BRC_ALLOW_READ_SKILLS=true
BRC_ALLOW_UPDATE_SKILLS=true
BRC_ALLOW_DELETE_SKILLS=true
BRC_ALLOW_EMAIL_SKILLS=true
BRC_ALLOW_BATCH_SKILLS=true
# Operator-only diagnostics; keep off for normal deployments
BRC_ALLOW_DEV_MODE=false
You can review the active policy at runtime with the brc_get_deployment_policy tool.
Connecting a company
Customers should connect companies through the secure Red connection page. Company connection credentials must not be sent through chat — they are entered only on the secure Red connection page, not in the chat window.
Customers can get or regenerate their company API keys in Big Red Cloud under Administration → API Keys.
The flow is:
- Ask the assistant to start a company connection. It returns a secure connection page link.
- On that page, enter a single company or upload a CSV for several companies at once. Company connection credentials are entered on the secure page, not in chat.
- The server validates each credential against Big Red Cloud before storing it. Credentials that fail validation are not saved.
- Return to the chat and provide the confirmation code shown on the success page.
- After confirm, the assistant reports which companies connected and which failed (if any). Invalid credentials appear in
failedCompanies immediately — you do not need to run a lookup first to discover a bad key.
Connection links are one-time use. Connected companies stay available for about the configured session duration (BRC_API_KEY_TTL_MINUTES, for example 240 minutes → about four hours), unless you disconnect or the connection expires.
Hosted HTTP and connectionRef
In hosted HTTP mode (for example Mistral/Vibe), brc_confirm_company_connection returns an opaque connectionRef in the tool JSON. MCP clients should preserve and silently reuse connectionRef / activeConnectionRef on later tool calls when the platform rotates session IDs. Connection persistence survives MCP session rotation where supported. This is an implementation detail for the client — assistants should not show connectionRef or redconn_… values to end users. Tool responses include assistantInstruction / presentationHint fields to reinforce that rule.
Helper tools:
- List connected companies in the session
- Clear one company connection
- Clear all company connections
Privacy-safe telemetry
On hosted deployments, Red may record anonymous operational telemetry so operators can understand approximate usage. Typical dimensions include anonymous client and connection-session identifiers, detected platform, deployment environment, tool name, and connected-company count.
Telemetry does not include API keys, credentials, raw connectionRef values, authorisation headers, customer data, or invoice data. These metrics are not verified Big Red Cloud user identities (OAuth user identity is not implemented).
Details for operators and developers: docs/TELEMETRY.md.
Red exposes a focused set of MCP tools, grouped by domain. Exact tool names and their endpoint mappings live in the source code under src/tools/.
For a detailed developer guide to the source layout and MCP tool coverage, see docs/TOOLS.md.
- Company setup and readiness — company setup configuration, financial year, options, readiness checks, transaction date validation, and getting-started guidance.
- Customers and suppliers — list/get/create/update/delete plus opening balances and account transactions.
- Products and sales reps — list/get/create/update/delete and product types.
- Sales documents — quotes, sales invoices, sales credit notes, and sales entries, including generated-reference variants and generating an invoice from a quote.
- Purchases and payments — purchases, payments, cash payments, and cash receipts.
- VAT and analysis lookups — VAT rates, VAT categories, VAT types, analysis categories, accounts, and related reference data.
- Nominal reports — nominal account listings and grouped/multi-company nominal reporting.
- Audit and session — session connection management and the session audit log.
<<<<<<< HEAD
- Help and training — Freshdesk articles, customer documentation, recorded webinars, upcoming webinars, and screenshot links through read-only help tools. No company connection is required.
=======
- Help and training — Freshdesk articles, customer documentation, recorded webinars, upcoming webinars, and screenshot links through read-only help tools. No company connection is required.
company-github/main
Batch variants exist for the main create workflows and apply the same safety checks as the single-record tools.
Company readiness check
brc_company_readiness_check is a read-only overall health check for a connected company. Overall statuses are:
readyready_with_warningsnot_readyconnection_problem
It reviews connection status plus relevant setup such as financial year, transaction date position, active Sales VAT rates, Sales Analysis categories, products, and sales representatives. Missing suppliers is reported as a purchase-setup warning and does not block sales-invoice readiness. Manual reference settings are treated as a warning / preflight consideration, not necessarily a blocker.
For a specific VAT-sensitive workflow (sales invoice, purchase, cash receipt, statement), use brc_check_transaction_settings instead — that tool checks one workflow’s processing settings, while readiness scores overall company readiness. Narrower helpers such as brc_validate_transaction_date, brc_get_company_processing_settings, and brc_get_company_reference_settings remain available for focused lookups.
Help and training resources
Red includes two read-only MCP tools for Big Red Cloud help and training questions:
brc_find_help_resources — searches official articles, customer documentation, recorded webinars, and upcoming webinars.brc_get_help_resource_details — returns the full details for a selected resource, including step-by-step guidance and relevant screenshot links where available.
These tools do not require a connected Big Red Cloud company.
Help answers may include:
- official Freshdesk articles;
- customer documentation;
- relevant screenshots;
- recorded YouTube training videos;
- upcoming webinar links.
Help-resource indexes are supplied by the deployment operator. The public repository does not include Big Red Cloud’s internal content-management or resource-upload workflow.
Help and training resources
Red includes two read-only MCP tools for Big Red Cloud help and training questions:
brc_find_help_resources — searches official articles, customer documentation, recorded webinars, and upcoming webinars.brc_get_help_resource_details — returns the full details for a selected resource, including step-by-step guidance and relevant screenshot links where available.
These tools do not require a connected Big Red Cloud company.
Help answers may include:
- official Freshdesk articles;
- customer documentation;
- relevant screenshots;
- recorded YouTube training videos;
- upcoming webinar links.
Help-resource indexes are supplied by the deployment operator. The public repository does not include Big Red Cloud’s internal content-management or resource-upload workflow.
Known limitations
- Some features depend on how the company is configured in Big Red Cloud.
- Email sending and bank write operations may require additional tenant configuration and may be disabled by deployment flags.
- Generated-reference behaviour can depend on Big Red Cloud tenant settings, and some generated-document endpoints may apply the tenant's current transaction date.
- Tool availability may vary by deployment policy.
- Anonymous telemetry counts approximate clients (for example browser/device cookies), not verified individual people.
- Platform detection may be
unknown when a client does not provide enough identifying information.
- Officially supported customer platforms are ChatGPT, Claude, and Mistral/Vibe; other MCP clients are not claimed as supported platforms.
Maintainers
This project is maintained by the Big Red Cloud software development team.
Status
Red is in BETA.
Red is an open-source MCP integration for Big Red Cloud and is under active development. Tool availability and behaviour may change between releases, and some capabilities are gated by deployment policy.
License
This project is licensed under the Apache License 2.0. See LICENSE for details.
Support and responsible disclosure
If you believe you have found a security issue, please report it to Big Red Cloud's support team.